#3383 Increase www unit tests
Merged 2 years ago by tkopecek. Opened 2 years ago by jcupova.

Increase www unit tests
Jana Cupova • 2 years ago  
@@ -0,0 +1,32 @@ 

+ import unittest

+ import koji

+ 

+ import mock

+ from .loadwebindex import webidx

+ 

+ 

+ class TestBuildrootInfo(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None

+         }

+         self.buildroot_id = '1'

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def test_buildrootinfo_exception(self):

+         """Test buildrootinfo function raises exception when buildroot ID is unknown."""

+         self.get_server.return_value = self.server

+         self.server.getBuildroot.return_value = None

+ 

+         with self.assertRaises(koji.GenericError) as cm:

+             webidx.buildrootinfo(self.environ, self.buildroot_id)

+         self.assertEqual(str(cm.exception), f'unknown buildroot ID: {self.buildroot_id}')

@@ -0,0 +1,95 @@ 

+ import mock

+ import unittest

+ import cgi

+ 

+ import koji

+ from io import BytesIO

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestBuildTargetCreate(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.buildtarget_id = '1'

+         self.buildtag_id = '11'

+         self.desttag_id = '99'

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None,

+         }

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def get_fs(self, urlencode_data):

+         urlencode_environ = {

+             'CONTENT_LENGTH': str(len(urlencode_data)),

+             'CONTENT_TYPE': 'application/x-www-form-urlencoded',

+             'QUERY_STRING': '',

+             'REQUEST_METHOD': 'POST',

+         }

+         data = BytesIO(urlencode_data)

+         data.seek(0)

+         return cgi.FieldStorage(fp=data, environ=urlencode_environ)

+ 

+     def test_buildtargetcreate_add_case_exception(self):

+         """Test buildtargetcreate function raises exception when buildtarget is not created."""

+         urlencode_data = b"add=True&name=testname&buildTag=11&destTag=99"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+         self.server.createBuildTarget.return_value = 1

+         self.server.getBuildTarget.return_value = None

+ 

+         with self.assertRaises(koji.GenericError) as cm:

+             webidx.buildtargetcreate(self.environ)

+         self.assertEqual(str(cm.exception), 'error creating build target "testname"')

+ 

+     def test_buildtargetcreate_add_case_valid(self):

+         """Test buildtargetcreate function valid case (add)."""

+         urlencode_data = b"add=True&name=testname&buildTag=11&destTag=99"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+         self.server.createBuildTarget.return_value = 1

+         self.server.getBuildTarget.return_value = {'id': 1}

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.buildtargetcreate(self.environ)

+         self.server.createBuildTarget.assert_called_with('testname', int(self.buildtag_id),

+                                                          int(self.desttag_id))

+         self.assertEqual(self.environ['koji.redirect'], 'buildtargetinfo?targetID=1')

+ 

+     def test_buildtargetcreate_cancel_case(self):

+         """Test buildtargetcreate function valid case (cancel)."""

+         urlencode_data = b"cancel=True"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+         self.server.getBuildTarget.return_value = {'id': self.buildtarget_id}

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.buildtargetcreate(self.environ)

+         self.server.createBuildTarget.assert_not_called()

+         self.assertEqual(self.environ['koji.redirect'], 'buildtargets')

@@ -5,6 +5,7 @@ 

  import koji

  from io import BytesIO

  from .loadwebindex import webidx

+ from koji.server import ServerRedirect

  

  

  class TestBuildTargetEdit(unittest.TestCase):
@@ -23,7 +24,10 @@ 

              'koji.currentUser': None,

          }

  

-         urlencode_data = b"save=True&name=testname&buildTag=11&destTag=99"

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def get_fs(self, urlencode_data):

          urlencode_environ = {

              'CONTENT_LENGTH': str(len(urlencode_data)),

              'CONTENT_TYPE': 'application/x-www-form-urlencoded',
@@ -32,43 +36,104 @@ 

          }

          data = BytesIO(urlencode_data)

          data.seek(0)

-         self.fs = cgi.FieldStorage(fp=data, environ=urlencode_environ)

+         return cgi.FieldStorage(fp=data, environ=urlencode_environ)

+ 

+     def test_buildtargetedit_exception(self):

+         """Test buildtargetedit function raises exception when build target not exists."""

+         urlencode_data = b"save=True&name=testname&buildTag=11&destTag=99"

+         fs = self.get_fs(urlencode_data)

  

          def __get_server(env):

              env['koji.session'] = self.server

-             env['koji.form'] = self.fs

+             env['koji.form'] = fs

              return self.server

  

          self.get_server.side_effect = __get_server

- 

-     def tearDown(self):

-         mock.patch.stopall()

- 

-     def test_buildtargetedit_exception(self):

-         """Test taskinfo function raises exception"""

          self.server.getBuildTarget.return_value = None

          self.get_server.return_value = self.server

  

          with self.assertRaises(koji.GenericError) as cm:

              webidx.buildtargetedit(self.environ, self.buildtarget_id)

-         self.assertEqual(str(cm.exception), 'No such build target: %s' % self.buildtarget_id)

+         self.assertEqual(str(cm.exception), f'No such build target: {self.buildtarget_id}')

  

      def test_buildtargetedit_exception_build_tag(self):

-         """Test taskinfo function raises exception"""

-         self.server.getBuildTarget.return_value = {'id': 1}

+         """Test buildtargetedit function raises exception when build tag not exists."""

+         urlencode_data = b"save=True&name=testname&buildTag=11&destTag=99"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+         self.server.getBuildTarget.return_value = {'id': int(self.buildtarget_id)}

          self.server.getTag.return_value = None

          self.get_server.return_value = self.server

  

          with self.assertRaises(koji.GenericError) as cm:

              webidx.buildtargetedit(self.environ, self.buildtarget_id)

-         self.assertEqual(str(cm.exception), 'No such tag ID: %s' % self.buildtag_id)

+         self.assertEqual(str(cm.exception), f'No such tag ID: {self.buildtag_id}')

  

      def test_buildtargetedit_exception_dest_tag(self):

-         """Test taskinfo function raises exception"""

-         self.server.getBuildTarget.return_value = {'id': 1}

-         self.server.getTag.side_effect = [{'id': 11}, None]

+         """Test buildtargetedit function raises exception when destination tag not exists."""

+         urlencode_data = b"save=True&name=testname&buildTag=11&destTag=99"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+         self.server.getBuildTarget.return_value = {'id': int(self.buildtarget_id)}

+         self.server.getTag.side_effect = [{'id': int(self.buildtag_id)}, None]

          self.get_server.return_value = self.server

  

          with self.assertRaises(koji.GenericError) as cm:

              webidx.buildtargetedit(self.environ, self.buildtarget_id)

-         self.assertEqual(str(cm.exception), 'No such tag ID: %s' % self.desttag_id)

+         self.assertEqual(str(cm.exception), f'No such tag ID: {self.desttag_id}')

+ 

+     def test_buildtargetedit_save_case_valid(self):

+         """Test buildtargetedit function valid case (save)."""

+         urlencode_data = b"save=True&name=testname&buildTag=11&destTag=99"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+ 

+         self.server.getBuildTarget.return_value = {'id': int(self.buildtarget_id)}

+         self.server.getTag.side_effect = [{'id': int(self.buildtag_id)},

+                                           {'id': int(self.desttag_id)}]

+         self.server.editBuildTarget.return_value = None

+         self.get_server.return_value = self.server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.buildtargetedit(self.environ, self.buildtarget_id)

+         self.assertEqual(self.environ['koji.redirect'],

+                          f'buildtargetinfo?targetID={self.buildtarget_id}')

+ 

+     def test_buildtargetedit_cancel_case(self):

+         """Test buildtargetedit function valid case (cancel)."""

+         self.server.getBuildTarget.return_value = {'id': int(self.buildtarget_id)}

+         urlencode_data = b"cancel=True"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.buildtargetedit(self.environ, self.buildtarget_id)

+         self.server.getBuildTarget.assert_called_with(int(self.buildtarget_id))

+         self.server.getTag.assert_not_called()

+         self.server.editBuildTarget.assert_not_called()

+         self.assertEqual(self.environ['koji.redirect'],

+                          f'buildtargetinfo?targetID={self.buildtarget_id}')

@@ -0,0 +1,55 @@ 

+ import unittest

+ import koji

+ 

+ import mock

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestCancelBuild(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None

+         }

+         self.build_id = '1'

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def test_cancelbuild_exception_unknown_build(self):

+         """Test cancelbuild function raises exception when build ID is unknown."""

+         self.get_server.return_value = self.server

+         self.server.getBuild.return_value = None

+ 

+         with self.assertRaises(koji.GenericError) as cm:

+             webidx.cancelbuild(self.environ, self.build_id)

+         self.assertEqual(str(cm.exception), f'unknown build ID: {self.build_id}')

+ 

+     def test_cancelbuild_unable_cancel(self):

+         """Test cancelbuild function raises exception when unable to cancel build."""

+         self.get_server.return_value = self.server

+         self.server.getBuild.return_value = {'id': int(self.build_id)}

+         self.server.cancelBuild.return_value = None

+ 

+         with self.assertRaises(koji.GenericError) as cm:

+             webidx.cancelbuild(self.environ, self.build_id)

+         self.assertEqual(str(cm.exception), 'unable to cancel build')

+ 

+     def test_cancelbuild_valid(self):

+         """Test cancelbuild function valid case."""

+         self.server.getBuild.return_value = {'id': int(self.build_id)}

+         self.server.cancelBuild.return_value = int(self.build_id)

+         self.get_server.return_value = self.server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.cancelbuild(self.environ, self.build_id)

+         self.server.getBuild.assert_called_with(int(self.build_id))

+         self.server.cancelBuild.assert_called_with(int(self.build_id))

+         self.assertEqual(self.environ['koji.redirect'], f'buildinfo?buildID={self.build_id}')

@@ -0,0 +1,33 @@ 

+ import unittest

+ 

+ import mock

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestCancelTask(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None

+         }

+         self.task_id = '1'

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def test_canceltask_valid(self):

+         """Test canceltask function valid case."""

+         self.server.cancelTask.return_value = None

+         self.get_server.return_value = self.server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.canceltask(self.environ, self.task_id)

+         self.server.cancelTask.assert_called_with(int(self.task_id))

+         self.assertEqual(self.environ['koji.redirect'], f'taskinfo?taskID={self.task_id}')

@@ -0,0 +1,35 @@ 

+ import unittest

+ 

+ import mock

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestDisableHost(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None

+         }

+         self.host_id = '1'

+         self.host_info = {'id': int(self.host_id), 'name': 'test-host'}

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def test_disablehost_valid(self):

+         """Test disablehost function valid case."""

+         self.server.getHost.return_value = self.host_info

+         self.server.disableHost.return_value = None

+         self.get_server.return_value = self.server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.disablehost(self.environ, str(self.host_id))

+         self.server.disableHost.assert_called_with(self.host_info['name'])

+         self.assertEqual(self.environ['koji.redirect'], f'hostinfo?hostID={self.host_id}')

@@ -0,0 +1,35 @@ 

+ import unittest

+ 

+ import mock

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestEnableHost(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None

+         }

+         self.host_id = '1'

+         self.host_info = {'id': int(self.host_id), 'name': 'test-host'}

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def test_enablehost_valid(self):

+         """Test enablehost function valid case."""

+         self.server.getHost.return_value = self.host_info

+         self.server.enableHost.return_value = None

+         self.get_server.return_value = self.server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.enablehost(self.environ, self.host_id)

+         self.server.enableHost.assert_called_with(self.host_info['name'])

+         self.assertEqual(self.environ['koji.redirect'], f'hostinfo?hostID={self.host_id}')

@@ -0,0 +1,33 @@ 

+ import unittest

+ 

+ import mock

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestFreeTask(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None

+         }

+         self.task_id = '1'

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def test_freetask_valid(self):

+         """Test freetask function valid case."""

+         self.server.freeTask.return_value = None

+         self.get_server.return_value = self.server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.freetask(self.environ, self.task_id)

+         self.server.freeTask.assert_called_with(int(self.task_id))

+         self.assertEqual(self.environ['koji.redirect'], f'taskinfo?taskID={self.task_id}')

@@ -0,0 +1,98 @@ 

+ import unittest

+ import koji

+ import cgi

+ 

+ import mock

+ from io import BytesIO

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestHostEdit(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None

+         }

+         self.host_id = '1'

+         self.host_info = {'id': int(self.host_id), 'name': 'test-host', 'enabled': True}

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def get_fs(self, urlencode_data):

+         urlencode_environ = {

+             'CONTENT_LENGTH': str(len(urlencode_data)),

+             'CONTENT_TYPE': 'application/x-www-form-urlencoded',

+             'QUERY_STRING': '',

+             'REQUEST_METHOD': 'POST',

+         }

+         data = BytesIO(urlencode_data)

+         data.seek(0)

+         return cgi.FieldStorage(fp=data, environ=urlencode_environ)

+ 

+     def test_hostedit_exception_host_not_existing(self):

+         """Test hostedit function raises exception when host ID not exists."""

+         self.get_server.return_value = self.server

+         self.server.getHost.return_value = None

+ 

+         with self.assertRaises(koji.GenericError) as cm:

+             webidx.hostedit(self.environ, self.host_id)

+         self.assertEqual(str(cm.exception), f'no host with ID: {self.host_id}')

+ 

+     def test_hostedit_save_case_valid(self):

+         """Test hostedit function valid case (save)."""

+         urlencode_data = b"save=True&arches=x86_64&capacity=1.0&description=test-desc&" \

+                          b"comment=test-comment&enable=True&channels=default"

+         fs = self.get_fs(urlencode_data)

+         self.server.getHost.return_value = self.host_info

+         self.server.editHost.return_value = True

+         self.server.listChannels.return_value = [{'id': 2, 'name': 'test-channel'}]

+         self.server.removeHostFromChannel.return_value = None

+         self.server.addHostToChannel.return_value = None

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.hostedit(self.environ, self.host_id)

+         self.server.getHost.assert_called_with(int(self.host_id))

+         self.server.editHost.assert_called_with(int(self.host_id), arches='x86_64', capacity=1.0,

+                                                 description='test-desc', comment='test-comment')

+         self.server.listChannels.assert_called_with(hostID=int(self.host_id))

+         self.server.removeHostFromChannel.assert_called_with(

+             self.host_info['name'], 'test-channel')

+         self.server.addHostToChannel.assert_called_with(self.host_info['name'], 'default')

+         self.assertEqual(self.environ['koji.redirect'], f'hostinfo?hostID={self.host_id}')

+ 

+     def test_hostedit_cancel_case_valid(self):

+         """Test hostedit function valid case (cancel)."""

+         urlencode_data = b"cancel=True"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+         self.server.getHost.return_value = self.host_info

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.hostedit(self.environ, self.host_id)

+         self.server.getHost.assert_called_with(int(self.host_id))

+         self.server.editHost.assert_not_called()

+         self.server.listChannels.assert_not_called()

+         self.server.removeHostFromChannel.assert_not_called()

+         self.server.addHostToChannel.assert_not_called()

+         self.assertEqual(self.environ['koji.redirect'], f'hostinfo?hostID={self.host_id}')

@@ -0,0 +1,115 @@ 

+ import mock

+ import unittest

+ import cgi

+ 

+ import koji

+ from io import BytesIO

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestNotificationCreate(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.buildtag_id = '11'

+         self.pkg_id = '2'

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': {'id': '1'},

+         }

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def get_fs(self, urlencode_data):

+         urlencode_environ = {

+             'CONTENT_LENGTH': str(len(urlencode_data)),

+             'CONTENT_TYPE': 'application/x-www-form-urlencoded',

+             'QUERY_STRING': '',

+             'REQUEST_METHOD': 'POST',

+         }

+         data = BytesIO(urlencode_data)

+         data.seek(0)

+         return cgi.FieldStorage(fp=data, environ=urlencode_environ)

+ 

+     def test_notificationcreate_add_case_not_logged(self):

+         """Test notificationcreate function raises exception when user is not logged."""

+         environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None,

+         }

+         urlencode_data = b"add=True&package=2&tag=11"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+ 

+         with self.assertRaises(koji.GenericError) as cm:

+             webidx.notificationcreate(environ)

+         self.assertEqual(str(cm.exception), 'not logged-in')

+ 

+     def test_notificationcreate_add_case_int(self):

+         """Test notificationcreate function valid case (add)"""

+         urlencode_data = b"add=True&package=2&tag=11&success_only=True"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+         self.server.createNotification.return_value = 11

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.notificationcreate(self.environ)

+         self.server.createNotification.assert_called_with('1', int(self.pkg_id),

+                                                           int(self.buildtag_id), True)

+         self.assertEqual(self.environ['koji.redirect'], 'index')

+ 

+     def test_notificationcreate_add_case_all(self):

+         """Test notificationcreate function valid case (add)"""

+         urlencode_data = b"add=True&package=all&tag=all"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+         self.server.createNotification.return_value = 11

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.notificationcreate(self.environ)

+         self.server.createNotification.assert_called_with('1', None, None, False)

+         self.assertEqual(self.environ['koji.redirect'], 'index')

+ 

+     def test_notificationcreate_cancel_case(self):

+         """Test notificationcreate function valid case (cancel)."""

+         urlencode_data = b"cancel=True"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.notificationcreate(self.environ)

+         self.server.createNotification.assert_not_called()

+         self.assertEqual(self.environ['koji.redirect'], 'index')

@@ -0,0 +1,43 @@ 

+ import unittest

+ import koji

+ 

+ import mock

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestNotificationDelete(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None

+         }

+         self.notification_id = '1'

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def test_notificationdelete_exception(self):

+         """Test notificationdelete function raises exception when notification ID not exists."""

+         self.server.getBuildNotification.return_value = None

+         self.get_server.return_value = self.server

+ 

+         with self.assertRaises(koji.GenericError) as cm:

+             webidx.notificationdelete(self.environ, self.notification_id)

+         self.assertEqual(str(cm.exception), f'no notification with ID: {self.notification_id}')

+ 

+     def test_notificationdelete_valid(self):

+         """Test notificationdelete function valid case."""

+         self.server.getBuildNotification.return_value = {'id': self.notification_id}

+         self.get_server.return_value = self.server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.notificationdelete(self.environ, self.notification_id)

+         self.server.deleteNotification.assert_called_with(self.notification_id)

+         self.assertEqual(self.environ['koji.redirect'], 'index')

@@ -0,0 +1,105 @@ 

+ import unittest

+ import koji

+ import cgi

+ 

+ import mock

+ from io import BytesIO

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestNotificationEdit(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None

+         }

+         self.notification_id = '1'

+         self.pkg_id = 2

+         self.tag_id = 11

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def get_fs(self, urlencode_data):

+         urlencode_environ = {

+             'CONTENT_LENGTH': str(len(urlencode_data)),

+             'CONTENT_TYPE': 'application/x-www-form-urlencoded',

+             'QUERY_STRING': '',

+             'REQUEST_METHOD': 'POST',

+         }

+         data = BytesIO(urlencode_data)

+         data.seek(0)

+         return cgi.FieldStorage(fp=data, environ=urlencode_environ)

+ 

+     def test_notificationedit_exception(self):

+         """Test notificationedit function raises exception when notification ID is not exists."""

+         self.server.getBuildNotification.return_value = None

+         self.get_server.return_value = self.server

+ 

+         with self.assertRaises(koji.GenericError) as cm:

+             webidx.notificationedit(self.environ, self.notification_id)

+         self.assertEqual(str(cm.exception), f'no notification with ID: {self.notification_id}')

+ 

+     def test_notificationedit_save_case_int(self):

+         """Test notificationedit function valid case (save)."""

+         urlencode_data = b"save=True&package=2&tag=11&success_only=True"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+         self.server.getBuildNotification.return_value = {'id': self.notification_id}

+         self.server.updateNotification.return_value = 1

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.notificationedit(self.environ, self.notification_id)

+         self.server.updateNotification.assert_called_with(self.notification_id, self.pkg_id,

+                                                           self.tag_id, True)

+         self.assertEqual(self.environ['koji.redirect'], 'index')

+ 

+     def test_notificationedit_save_case_all(self):

+         """Test notificationedit function valid case (all)."""

+         urlencode_data = b"save=True&package=all&tag=all"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.server.getBuildNotification.return_value = {'id': self.notification_id}

+         self.get_server.side_effect = __get_server

+         self.server.updateNotification.return_value = 1

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.notificationedit(self.environ, self.notification_id)

+         self.server.updateNotification.assert_called_with(self.notification_id, None, None, False)

+         self.assertEqual(self.environ['koji.redirect'], 'index')

+ 

+     def test_notificationedit_cancel_case(self):

+         """Test notificationedit function valid case (cancel)."""

+         urlencode_data = b"cancel=True"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.server.getBuildNotification.return_value = {'id': self.notification_id}

+         self.get_server.side_effect = __get_server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.notificationedit(self.environ, self.notification_id)

+         self.server.updateNotification.assert_not_called()

+         self.assertEqual(self.environ['koji.redirect'], 'index')

@@ -0,0 +1,33 @@ 

+ import unittest

+ 

+ import mock

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestResubmitTask(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None

+         }

+         self.task_id = 1

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def test_resubmittask_valid(self):

+         """Test resubmittask function valid case."""

+         self.server.resubmitTask.return_value = 2

+         self.get_server.return_value = self.server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.resubmittask(self.environ, str(self.task_id))

+         self.server.resubmitTask.assert_called_with(self.task_id)

+         self.assertEqual(self.environ['koji.redirect'], 'taskinfo?taskID=2')

@@ -0,0 +1,73 @@ 

+ import unittest

+ import cgi

+ 

+ import mock

+ from io import BytesIO

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestTagCreate(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None

+         }

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def get_fs(self, urlencode_data):

+         urlencode_environ = {

+             'CONTENT_LENGTH': str(len(urlencode_data)),

+             'CONTENT_TYPE': 'application/x-www-form-urlencoded',

+             'QUERY_STRING': '',

+             'REQUEST_METHOD': 'POST',

+         }

+         data = BytesIO(urlencode_data)

+         data.seek(0)

+         return cgi.FieldStorage(fp=data, environ=urlencode_environ)

+ 

+     def test_tagcreate_add_case_valid(self):

+         """Test tagcreate function valid case (add)"""

+         urlencode_data = b"add=True&name=testname&arches=x86_64&locked=True&permission=1" \

+                          b"&maven_support=True&maven_include_all=True"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+         self.server.createTag.return_value = 1

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.tagcreate(self.environ)

+         self.server.createTag.assert_called_with('testname', arches='x86_64', locked=True,

+                                                  perm=1, maven_support=True,

+                                                  maven_include_all=True)

+         self.assertEqual(self.environ['koji.redirect'], 'taginfo?tagID=1')

+ 

+     def test_tagcreate_cancel_case_valid(self):

+         """Test tagcreate function valid cases (cancel)."""

+         urlencode_data = b"cancel=True"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.tagcreate(self.environ)

+         self.server.createTag.assert_not_called()

+         self.assertEqual(self.environ['koji.redirect'], 'tags')

@@ -0,0 +1,44 @@ 

+ import mock

+ import unittest

+ 

+ import koji

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestTagDelete(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None

+         }

+         self.tag_id = '1'

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def test_tagdelete_exception(self):

+         """Test tagdelete function raises exception when tag not exists."""

+         self.get_server.return_value = self.server

+         self.server.getTag.return_value = None

+ 

+         with self.assertRaises(koji.GenericError) as cm:

+             webidx.tagdelete(self.environ, self.tag_id)

+         self.assertEqual(str(cm.exception), f'no tag with ID: {self.tag_id}')

+ 

+     def test_tagdelete_valid(self):

+         """Test taskinfo function valid case."""

+         self.server.getTag.return_value = {'id': int(self.tag_id)}

+         self.server.deleteTag.return_value = None

+         self.get_server.return_value = self.server

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.tagdelete(self.environ, self.tag_id)

+         self.server.deleteTag.assert_called_with(int(self.tag_id))

+         self.assertEqual(self.environ['koji.redirect'], 'tags')

@@ -0,0 +1,86 @@ 

+ import unittest

+ import koji

+ import cgi

+ 

+ import mock

+ from io import BytesIO

+ from .loadwebindex import webidx

+ from koji.server import ServerRedirect

+ 

+ 

+ class TestTagEdit(unittest.TestCase):

+     def setUp(self):

+         self.get_server = mock.patch.object(webidx, "_getServer").start()

+         self.assert_login = mock.patch.object(webidx, "_assertLogin").start()

+         self.server = mock.MagicMock()

+         self.environ = {

+             'koji.options': {

+                 'SiteName': 'test',

+                 'KojiFilesURL': 'https://server.local/files',

+             },

+             'koji.currentUser': None

+         }

+         self.tag_id = '1'

+ 

+     def tearDown(self):

+         mock.patch.stopall()

+ 

+     def get_fs(self, urlencode_data):

+         urlencode_environ = {

+             'CONTENT_LENGTH': str(len(urlencode_data)),

+             'CONTENT_TYPE': 'application/x-www-form-urlencoded',

+             'QUERY_STRING': '',

+             'REQUEST_METHOD': 'POST',

+         }

+         data = BytesIO(urlencode_data)

+         data.seek(0)

+         return cgi.FieldStorage(fp=data, environ=urlencode_environ)

+ 

+     def test_tagedit_exception(self):

+         """Test tagedit function raises exception when tag ID not exists."""

+         self.get_server.return_value = self.server

+         self.server.getTag.return_value = None

+ 

+         with self.assertRaises(koji.GenericError) as cm:

+             webidx.tagedit(self.environ, self.tag_id)

+         self.assertEqual(str(cm.exception), f'no tag with ID: {self.tag_id}')

+ 

+     def test_tagedit_add_case_valid(self):

+         """Test tagedit function valid case (save)."""

+         urlencode_data = b"save=True&name=testname&arches=x86_64&locked=True&permission=1" \

+                          b"&maven_support=True&maven_include_all=True"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+         self.server.editTag2.return_value = None

+         self.server.getTag.return_value = {'id': int(self.tag_id)}

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.tagedit(self.environ, self.tag_id)

+         self.server.editTag2.assert_called_with(1, arches='x86_64', locked=True, perm=1,

+                                                 maven_support=True, maven_include_all=True,

+                                                 name='testname')

+         self.assertEqual(self.environ['koji.redirect'], f'taginfo?tagID={self.tag_id}')

+ 

+     def test_tagedit_cancel_case_valid(self):

+         """Test tagedit function valid case (cancel)."""

+         urlencode_data = b"cancel=True"

+         fs = self.get_fs(urlencode_data)

+ 

+         def __get_server(env):

+             env['koji.session'] = self.server

+             env['koji.form'] = fs

+             return self.server

+ 

+         self.get_server.side_effect = __get_server

+         self.server.getTag.return_value = {'id': int(self.tag_id)}

+ 

+         with self.assertRaises(ServerRedirect):

+             webidx.tagedit(self.environ, self.tag_id)

+         self.server.editTag2.assert_not_called()

+         self.assertEqual(self.environ['koji.redirect'], f'taginfo?tagID={self.tag_id}')