Esempio n. 1
0
 def _setUp(self):
     self.useFixture(
         MonkeyPatch('twisted.internet.defer.Deferred.debug',
                     self._debug_setting))
     self.useFixture(
         MonkeyPatch('twisted.internet.base.DelayedCall.debug',
                     self._debug_setting))
Esempio n. 2
0
 def test_patch_and_restore(self):
     fixture = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.reference', 45)
     self.assertEqual(23, reference)
     fixture.setUp()
     try:
         self.assertEqual(45, reference)
     finally:
         fixture.cleanUp()
         self.assertEqual(23, reference)
Esempio n. 3
0
 def test_patch_missing_attribute(self):
     fixture = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.new_attr', True)
     self.assertFalse('new_attr' in globals())
     fixture.setUp()
     try:
         self.assertEqual(True, new_attr)
     finally:
         fixture.cleanUp()
         self.assertFalse('new_attr' in globals())
Esempio n. 4
0
 def test_delete_existing_attribute(self):
     fixture = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.reference',
         MonkeyPatch.delete)
     self.assertEqual(23, reference)
     fixture.setUp()
     try:
         self.assertFalse('reference' in globals())
     finally:
         fixture.cleanUp()
         self.assertEqual(23, reference)
Esempio n. 5
0
 def test_delete_missing_attribute(self):
     fixture = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.new_attr',
         MonkeyPatch.delete)
     self.assertFalse('new_attr' in globals())
     fixture.setUp()
     try:
         self.assertFalse('new_attr' in globals())
     finally:
         fixture.cleanUp()
         self.assertFalse('new_attr' in globals())
Esempio n. 6
0
 def test_double_patch_classmethod(self):
     oldmethod = C.foo_cls
     oldmethod_inst = C().foo_cls
     fixture1 = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.C.foo_cls', fake)
     fixture2 = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.C.foo_cls', fake2)
     with fixture1:
         with fixture2:
             C.foo_cls()
             C().foo_cls()
     self._check_restored_static_or_class_method(oldmethod, oldmethod_inst,
                                                 C, 'foo_cls')
Esempio n. 7
0
 def test_double_patch_instancemethod(self):
     oldmethod = C.foo
     oldmethod_inst = C().foo
     fixture1 = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.C.foo', fake)
     fixture2 = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.C.foo', fake2)
     with fixture1:
         with fixture2:
             C().foo()
     self.assertEqual(oldmethod, C.foo)
     # The method address changes with each instantiation of C, and method
     # equivalence just tests that. Compare the code objects instead.
     self.assertEqual(oldmethod_inst.__code__, C().foo.__code__)
Esempio n. 8
0
 def test_double_patch_staticmethod(self):
     oldmethod = C.foo_static
     oldmethod_inst = C().foo_static
     fixture1 = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.C.foo_static',
         fake_no_args)
     fixture2 = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.C.foo_static',
         fake_static)
     with fixture1:
         with fixture2:
             C.foo_static()
             C().foo_static()
     self._check_restored_static_or_class_method(oldmethod, oldmethod_inst,
                                                 C, 'foo_static')
Esempio n. 9
0
    def setUp(self):
        super(FunctionalTest, self).setUp()
        self.test_data_dir = ''.join((os.path.abspath(os.getcwd()), '/',
                                      self.test_data_subdir))
        self.maildir = TempDir()
        self.useFixture(self.maildir)

        self.fake_getmtime_val = 123456.7
        self.useFixture(MonkeyPatch('os.path.getmtime', self.fake_getmtime))

        config = {
            'app': {
                'root': 'mailase.api.controllers.root.RootController',
                'modules': ['mailase.api'],
            },
            'mail': {
                'maildirs': self.maildir.path
            },
            'search': {
                'server_url': ['http://localhost:9200'],
                'index': 'mailase_test'
            }
        }
        self.app = load_test_app(config)
        self.mailboxes = {}
        self.mua_subdirs = {}
Esempio n. 10
0
 def test_isolated_runs_multiple_processes(self):
     ui, cmd = self.get_test_ui_and_cmd(options=[('isolated', True)])
     cmd.repository_factory = memory.RepositoryFactory()
     self.setup_repo(cmd, ui)
     self.set_config('[DEFAULT]\ntest_command=foo $IDLIST $LISTOPT\n'
                     'test_id_option=--load-list $IDFILE\n'
                     'test_list_option=--list\n')
     params, capture_ids = self.capture_ids(list_result=['ab', 'cd', 'ef'])
     self.useFixture(
         MonkeyPatch(
             'testrepository.testcommand.TestCommand.get_run_command',
             capture_ids))
     cmd_result = cmd.execute()
     self.assertEqual([
         ('results', Wildcard),
         ('summary', True, 0, -3, None, None, [('id', 1, None)]),
         ('results', Wildcard),
         ('summary', True, 0, 0, None, None, [('id', 2, None)]),
         ('results', Wildcard),
         ('summary', True, 0, 0, None, None, [('id', 3, None)]),
     ], ui.outputs)
     self.assertEqual(0, cmd_result)
     # once to list, then 3 each executing one test.
     self.assertThat(params, HasLength(4))
     self.assertThat(params[0][1], Equals(None))
     self.assertThat(params[1][1], Equals(['ab']))
     self.assertThat(params[2][1], Equals(['cd']))
     self.assertThat(params[3][1], Equals(['ef']))
Esempio n. 11
0
    def _mock_list_images(self, return_value, image_name, expected_resp):

        mock_function = mock.Mock(return_value=return_value)
        func2mock = self.FAKE_CLIENT_MOCK + '.list_images'
        self.useFixture(MonkeyPatch(func2mock, mock_function))
        resp = self.Service._find_image(image_id=None, image_name=image_name)
        self.assertEqual(resp, expected_resp)
Esempio n. 12
0
 def test_correct_opal_keygen_command_executed(self):
     # Check that calling generateOpalKeys() will generate the
     # expected command.
     self.setUpPPA()
     self.setUpOpalKeys(create=False)
     fake_call = FakeMethod(result=0)
     self.useFixture(MonkeyPatch("subprocess.call", fake_call))
     upload = SigningUpload()
     upload.setTargetDirectory(self.archive, "test_1.0_amd64.tar.gz",
                               "distroseries")
     upload.generateOpalKeys()
     self.assertEqual(2, fake_call.call_count)
     # Assert the actual command matches.
     args = fake_call.calls[0][0][0]
     # Sanitise the keygen tmp file.
     if args[11].endswith('.keygen'):
         args[11] = 'XXX.keygen'
     expected_cmd = [
         'openssl', 'req', '-new', '-nodes', '-utf8', '-sha512', '-days',
         '3650', '-batch', '-x509', '-config', 'XXX.keygen', '-outform',
         'PEM', '-out', self.opal_pem, '-keyout', self.opal_pem
     ]
     self.assertEqual(expected_cmd, args)
     args = fake_call.calls[1][0][0]
     expected_cmd = [
         'openssl', 'x509', '-in', self.opal_pem, '-outform', 'DER', '-out',
         self.opal_x509
     ]
     self.assertEqual(expected_cmd, args)
Esempio n. 13
0
 def test_correct_uefi_keygen_command_executed(self):
     # Check that calling generateUefiKeys() will generate the
     # expected command.
     self.setUpPPA()
     self.setUpUefiKeys(create=False)
     fake_call = FakeMethod(result=0)
     self.useFixture(MonkeyPatch("subprocess.call", fake_call))
     upload = SigningUpload()
     upload.setTargetDirectory(self.archive, "test_1.0_amd64.tar.gz",
                               "distroseries")
     upload.generateUefiKeys()
     self.assertEqual(1, fake_call.call_count)
     # Assert the actual command matches.
     args = fake_call.calls[0][0][0]
     expected_cmd = [
         'openssl',
         'req',
         '-new',
         '-x509',
         '-newkey',
         'rsa:2048',
         '-subj',
         self.testcase_cn,
         '-keyout',
         self.key,
         '-out',
         self.cert,
         '-days',
         '3650',
         '-nodes',
         '-sha256',
     ]
     self.assertEqual(expected_cmd, args)
Esempio n. 14
0
 def test_empty_requirements_file(self):
     fixture = self.useFixture(MainFixture())
     self.useFixture(MonkeyPatch('sys.argv', ['bindep']))
     with open(fixture.path + '/other-requirements.txt', 'wt'):
         pass
     self.assertEqual(0, main())
     self.assertEqual('', fixture.logger.output)
Esempio n. 15
0
 def test_load_list_passes_ids(self):
     list_file = tempfile.NamedTemporaryFile()
     self.addCleanup(list_file.close)
     expected_ids = set(['foo', 'quux', 'bar'])
     write_list(list_file, expected_ids)
     list_file.flush()
     ui, cmd = self.get_test_ui_and_cmd(options=[('load_list',
                                                  list_file.name)])
     cmd.repository_factory = memory.RepositoryFactory()
     self.setup_repo(cmd, ui)
     self.set_config(
         '[DEFAULT]\ntest_command=foo $IDOPTION\ntest_id_option=--load-list $IDFILE\n'
     )
     params, capture_ids = self.capture_ids()
     self.useFixture(
         MonkeyPatch(
             'testrepository.testcommand.TestCommand.get_run_command',
             capture_ids))
     cmd_result = cmd.execute()
     self.assertEqual(
         [('results', Wildcard),
          ('summary', True, 0, -3, None, None, [('id', 1, None)])],
         ui.outputs)
     self.assertEqual(0, cmd_result)
     self.assertEqual([[Wildcard, expected_ids, [], None]], params)
 def _test_create_flavor(self, no_rng=False):
     return_value = {"flavor": {"id": "MyFakeID", "name": "MyID"}}
     self.Service.flavor_list = []
     client = self.CLIENT_MOCK
     mock_function = mock.Mock(return_value=return_value)
     self.useFixture(MonkeyPatch(client + '.create_flavor', mock_function))
     mock_function = mock.Mock(return_value={})
     self.useFixture(
         MonkeyPatch(client + '.set_flavor_extra_spec', mock_function))
     resp = self.Service.create_flavor("MyID",
                                       C.DEFAULT_FLAVOR_RAM,
                                       C.DEFAULT_FLAVOR_VCPUS,
                                       C.DEFAULT_FLAVOR_DISK,
                                       no_rng=no_rng)
     self.assertEqual(resp, return_value['flavor']['id'])
     return mock_function
Esempio n. 17
0
 def test_patch_boundmethod_with_classmethod(self):
     oldmethod = INST_C.foo
     fixture = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.INST_C.foo', D.bar_cls)
     with fixture:
         INST_C.foo()
     self.assertEqual(oldmethod, INST_C.foo)
Esempio n. 18
0
 def test_missing_default_requirements_file(self):
     fixture = self.useFixture(MainFixture())
     self.useFixture(MonkeyPatch('sys.argv', ['bindep']))
     self.assertEqual(1, main())
     self.assertEqual(
         'Neither file bindep.txt nor file other-requirements.txt exist.\n',
         fixture.logger.output)
 def test_patch_staticmethod(self):
     oldfoo = C.foo
     fixture = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.C.foo', bar)
     with fixture:
         pass
     self.assertEqual(oldfoo, C.foo)
Esempio n. 20
0
 def test_find_image_by_id(self):
     expected_resp = {"id": "001", "status": "active", "name": "ImageName"}
     mock_function = mock.Mock(return_value=expected_resp)
     func2mock = self.FAKE_CLIENT_MOCK + '.show_image'
     self.useFixture(MonkeyPatch(func2mock, mock_function))
     resp = self.Service._find_image(image_id="001", image_name="cirros")
     self.assertEqual(resp, expected_resp)
Esempio n. 21
0
 def test_regex_test_filter_with_explicit_ids(self):
     ui, cmd = self.get_test_ui_and_cmd(args=('g1', '--', 'bar', 'quux'),
                                        options=[('failing', True)])
     cmd.repository_factory = memory.RepositoryFactory()
     self.setup_repo(cmd, ui)
     self.set_config('[DEFAULT]\ntest_command=foo $IDLIST $LISTOPT\n'
                     'test_id_option=--load-list $IDFILE\n'
                     'test_list_option=--list\n')
     params, capture_ids = self.capture_ids()
     self.useFixture(
         MonkeyPatch(
             'testrepository.testcommand.TestCommand.get_run_command',
             capture_ids))
     cmd_result = cmd.execute()
     self.assertEqual(
         [('results', Wildcard),
          ('summary', True, 0, -3, None, None, [('id', 1, None)])],
         ui.outputs)
     self.assertEqual(0, cmd_result)
     self.assertThat(params[0][1], Equals(['failing1', 'failing2']))
     self.assertThat(params[0][2],
                     MatchesListwise([Equals('bar'),
                                      Equals('quux')]))
     self.assertThat(params[0][3], MatchesListwise([Equals('g1')]))
     self.assertThat(params, HasLength(1))
Esempio n. 22
0
 def test_missing_specific_requirements_file(self):
     fixture = self.useFixture(MainFixture())
     self.useFixture(
         MonkeyPatch('sys.argv',
                     ['bindep', '--file', 'alternative-requirements.txt']))
     self.assertEqual(1, main())
     self.assertEqual('Error reading file alternative-requirements.txt.\n',
                      fixture.logger.output)
Esempio n. 23
0
 def test_patch_function_with_boundmethod(self):
     oldmethod = fake_no_args
     fixture = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.fake_no_args',
         D().bar)
     with fixture:
         fake_no_args()
     self.assertEqual(oldmethod, fake_no_args)
Esempio n. 24
0
 def test_patch_boundmethod_with_function(self):
     oldmethod = INST_C.foo
     fixture = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.INST_C.foo',
         fake_no_args)
     with fixture:
         INST_C.foo()
     self.assertEqual(oldmethod, INST_C.foo)
Esempio n. 25
0
 def test_urlfetch_no_proxy_by_default(self):
     """urlfetch does not use a proxy by default."""
     self.pushConfig('launchpad', http_proxy='http://proxy.example:3128/')
     fake_send = FakeMethod(result=Response())
     self.useFixture(
         MonkeyPatch('requests.adapters.HTTPAdapter.send', fake_send))
     urlfetch('http://example.com/')
     self.assertEqual({}, fake_send.calls[0][1]['proxies'])
Esempio n. 26
0
 def test_patch_function_with_partial(self):
     oldmethod = fake_no_args
     fixture = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.fake_no_args',
         functools.partial(fake, 1))
     with fixture:
         (ret, ) = fake_no_args()
         self.assertEqual(1, ret)
     self.assertEqual(oldmethod, fake_no_args)
Esempio n. 27
0
 def setUp(self):
     super(MainFixture, self).setUp()
     self.logger = self.useFixture(FakeLogger())
     self.path = self.useFixture(TempDir()).path
     self.addCleanup(os.chdir, self.path)
     os.chdir(self.path)
     fake_lsb = b'Ubuntu\n14.04\nTrusty'
     self.useFixture(
         MonkeyPatch('subprocess.check_output', lambda *a, **k: fake_lsb))
Esempio n. 28
0
 def test_specific_requirements_file(self):
     fixture = self.useFixture(MainFixture())
     self.useFixture(
         MonkeyPatch('sys.argv',
                     ['bindep', '--file', 'alternative-requirements.txt']))
     with open(fixture.path + '/alternative-requirements.txt', 'wt'):
         pass
     self.assertEqual(0, main())
     self.assertEqual('', fixture.logger.output)
 def setUp(self):
     super(TestFlavors, self).setUp()
     self.conf = self._get_conf("v2.0", "v3")
     self.client = self._get_clients(self.conf).flavors
     return_value = {"flavors": [{"id": "MyFakeID", "name": "MyID"}]}
     mock_function = mock.Mock(return_value=return_value)
     self.useFixture(
         MonkeyPatch(self.CLIENT_MOCK + '.list_flavors', mock_function))
     self.Service = Flavors(self.client, True, self.conf, 64, 1)
Esempio n. 30
0
 def _get_creds(self, conf, admin=False, v2=False):
     # We return creds configured to v2 or v3
     func2mock = 'config_tempest.credentials.Credentials._list_versions'
     return_value = self.FAKE_V3_VERSIONS
     if v2:
         return_value = self.FAKE_V2_VERSIONS
     mock_function = mock.Mock(return_value=return_value)
     self.useFixture(MonkeyPatch(func2mock, mock_function))
     return Credentials(conf, admin)
 def test_get_auth_provider_keystone_v3(self):
     # check if method returns KeystoneV3AuthProvider
     # make isinstance return True
     mockIsInstance = mock.Mock(return_value=True)
     self.useFixture(
         MonkeyPatch('config_tempest.credentials.isinstance',
                     mockIsInstance))
     mock_function = mock.Mock()
     # mock V3Provider, if other provider is called, it fails
     func2mock = 'config_tempest.credentials.auth.KeystoneV3AuthProvider'
     self.useFixture(MonkeyPatch(func2mock, mock_function))
     resp = self.creds.get_auth_provider()
     self.assertEqual(resp, mock_function())
     # check parameters of returned function
     self.creds.get_auth_provider()
     mock_function.assert_called_with(self.creds.tempest_creds,
                                      'http://172.16.52.151:5000/v3',
                                      'true', None)
 def test_find_flavor_by_name(self):
     return_value = {"flavors": self.FLAVORS_LIST}
     mock_function = mock.Mock(return_value=return_value)
     self.useFixture(
         MonkeyPatch(self.CLIENT_MOCK + '.list_flavors', mock_function))
     resp = self.Service.find_flavor_by_name("MyID")
     self.assertEqual(resp, "MyFakeID")
     # test no flavor found case
     resp = self.Service.find_flavor_by_name("NotExist")
     self.assertEqual(resp, None)
Esempio n. 33
0
 def test_patch_unboundmethod_with_function(self):
     oldmethod = C.foo
     fixture = MonkeyPatch(
         'fixtures.tests._fixtures.test_monkeypatch.C.foo', fake)
     with fixture:
         c = C()
         target_self, arg = c.foo(1)
         self.expectThat(target_self, Is(c))
         self.assertTrue(1, arg)
     self.assertEqual(oldmethod, C.foo)
 def test_init_manager_as_admin(self):
     self.creds = self._get_creds(self.conf, True)
     mock_function = mock.Mock(return_value={"id": "my_fake_id"})
     func2mock = ('config_tempest.clients.ProjectsClient.'
                  'get_project_by_name')
     self.useFixture(MonkeyPatch(func2mock, mock_function))
     ClientManager(self.conf, self.creds)
     # check if admin project id was set
     admin_project_id = self.conf.get("auth", "admin_project_id")
     self.assertEqual(admin_project_id, "my_fake_id")