Пример #1
0
  def test_user_removing(self):
    mocked_repo = MagicMock()
    mocked_repository = MagicMock()
    mocked_user = MagicMock()

    mock_single_user = MagicMock()
    mock_single_user.name = 'another_user'
    mock_single_user.__str__ = lambda x: 'another_user'

    mocked_repository.name = 'test_repo'
    mocked_repository.path = 'path'

    mocked_user.get.return_value = mock_single_user
    mocked_repo.users = ['user']

    with patch.multiple('models.lists.users',
                        Repo=MagicMock(return_value=mocked_repo),
                        User=mocked_user):
      repo_users = ListUsers(mocked_repository)
      repo_users.remove('test')

      pattern = r'(\s*)([RW+DC]*)(\s*)=(\s*)%s' % 'another_user'
      mocked_repo.replace.assert_called_once_with(pattern, "")

      message = "Deleted user another_user from repository test_repo"
      mocked_repository.git.commit.has_calls([call(['conf'], message)])
Пример #2
0
def test_Downloader_extract(tarfile):
    downloader = Downloader("http://example.com")
    downloader.tarFile = "/tmp/test.tar"
    downloader.workDir = "/tmp"

    tar = MagicMock()
    tarfile.open.return_value = tar

    badfile = MagicMock()
    badfile.name = ".."
    tar.__iter__.return_value = [badfile]

    # Exception: Archive contains a forbidden path: ..
    assert_raises(Exception, downloader.extract)

    badfile.name = "/bin/bash"
    tar.__iter__.return_value = [badfile]

    # Exception: Archive contains an absolute path: /bin/bash
    assert_raises(Exception, downloader.extract)

    srcdir = MagicMock()
    srcdir.name = "project-0123456789abcdef"
    tar.__iter__.return_value = [srcdir]

    # Exception: Repository does not contain a Dockerfile
    assert_raises(Exception, downloader.extract)

    dockerfile = MagicMock()
    dockerfile.name = "project-0123456789abcdef/Dockerfile"
    tar.__iter__.return_value = [srcdir, dockerfile]

    rundir = downloader.extract()
    assert rundir == "/tmp/project-0123456789abcdef"
Пример #3
0
def create_mock_list_with_name_attribute():
    member1 = MagicMock(id=1)
    member2 = MagicMock(id=2)
    member1.name = 'testerino'
    member2.name = 'anotherone'
    content = MagicMock(content=[member1, member2])
    return content
Пример #4
0
 def test_4_cycle_throws_circ_dependencies_error(self):
     """
     Ensures
         o - o
         |   |
         o - o
     throws circular dependency error
     """
     stack1 = MagicMock(Spec=Stack)
     stack2 = MagicMock(Spec=Stack)
     stack3 = MagicMock(Spec=Stack)
     stack4 = MagicMock(Spec=Stack)
     stack1.dependencies = ["stack4"]
     stack1.name = "stack1"
     stack2.dependencies = ["stack1"]
     stack2.name = "stack2"
     stack3.dependencies = ["stack2"]
     stack3.name = "stack3"
     stack4.dependencies = ["stack3"]
     stack4.name = "stack4"
     stacks = {
         "stack1": stack1,
         "stack2": stack2,
         "stack3": stack3,
         "stack4": stack4
     }
     self.environment.stacks = stacks
     with pytest.raises(CircularDependenciesError) as ex:
         self.environment._check_for_circular_dependencies()
     assert all(x in str(ex) for x in ['stack4', 'stack3', 'stack2',
                                       'stack1'])
Пример #5
0
  def test_user_edit_permissions(self):
    mocked_repo = MagicMock()
    mocked_repository = MagicMock()
    mocked_user = MagicMock()

    mock_single_user = MagicMock()
    mock_single_user.name = 'another_user'
    mock_single_user.__str__ = lambda x: 'another_user'

    mocked_repository.name = 'test_repo'
    mocked_repository.path = 'path'

    mocked_user.get.return_value = mock_single_user
    mocked_repo.users = ['user']

    with patch.multiple('models.lists.users',
                        Repo=MagicMock(return_value=mocked_repo),
                        User=mocked_user):
      repo_users = ListUsers(mocked_repository)
      repo_users.edit('test', 'R')

      pattern = r'(\s*)([RW+DC]*)(\s*)=(\s*)%s' % 'another_user'
      string = r"\n    %s    =    %s" % ('R', 'another_user')
      mocked_repo.replace.assert_called_once_with(pattern, string)

      message = "User another_user has R permission for repository test_repo"
      mocked_repository.git.commit.has_calls([call(['conf'], message)])
Пример #6
0
    def test_add_tasks_po_from_filextension(self, find_mock, po_mock):
        """Test add_tasks po without specifying file extension works."""
        project = MagicMock()
        project.name = 'name'
        project.short_name = 'short_name'
        project.description = 'description'
        project.info = dict()
        find_mock.return_value = project

        entry = MagicMock()
        entry.msgid = 'English'
        entry.msgtr = ''
        po = MagicMock()
        po.untranslated_entries.return_value = [entry]
        po_mock.return_value = po

        tasks = MagicMock()
        tasks.name = 'tasks.po'
        tasks.read.return_value = json.dumps([{'info': {'msgid': 'English',
                                                        'msgtr':''}}])

        pbclient = MagicMock()
        pbclient.create_task.return_value = {'id': 1, 'info': {'msgid': 'English',
                                                               'msgtr': ''}}
        self.config.pbclient = pbclient
        res = _add_tasks(self.config, tasks, None, 0, 30)
        assert res == '1 tasks added to project: short_name', res
Пример #7
0
 def test_DAG_diamond_with_triangle_throws_no_circ_dependencies_error(self):
     """
     Ensures
         o
        / \
       o   o
        \ / \
         o ->o
     throws no circular dependency error
     """
     stack1 = MagicMock(Spec=Stack)
     stack2 = MagicMock(Spec=Stack)
     stack3 = MagicMock(Spec=Stack)
     stack4 = MagicMock(Spec=Stack)
     stack5 = MagicMock(Spec=Stack)
     stack1.dependencies = ["stack2", "stack3"]
     stack1.name = "stack1"
     stack2.dependencies = ["stack4"]
     stack2.name = "stack2"
     stack3.dependencies = ["stack4", "stack5"]
     stack3.name = "stack3"
     stack4.dependencies = ["stack5"]
     stack4.name = "stack4"
     stack5.dependencies = []
     stack5.name = "stack5"
     stacks = {
         "stack1": stack1,
         "stack2": stack2,
         "stack3": stack3,
         "stack4": stack4,
         "stack5": stack5
     }
     self.environment.stacks = stacks
     self.environment._check_for_circular_dependencies()
Пример #8
0
    def test_users_set(self):
        mocked_repo = MagicMock()
        mocked_repository = MagicMock(config="")
        mocked_repository.get_config.return_value = ""
        mocked_user = MagicMock()

        mock_single_user = MagicMock()
        mock_single_user.name = 'user'

        mocked_repository.name = 'test_repo'
        mocked_repository.path = 'path'

        mocked_user.get.return_value = mock_single_user

        with patch.multiple('pyolite.models.lists.users',
                            Repo=MagicMock(return_value=mocked_repo),
                            User=mocked_user):
            repo_users = ListUsers(mocked_repository)
            repo_users.set((('mocked', 'R'), ('mocked', 'RW+')))

            serialized_users = "repo test_repo\n    R     =    user\n" \
                               "    RW+     =    user\n"
            mocked_repo.overwrite.assert_called_once_with(serialized_users)

            message = "Initialized repository test_repo with users: test, user"
            mocked_repository.git.commit.has_calls([call(['conf'], message)])
Пример #9
0
    def test___eq__(self, mock_name, mock_callables, mock_priority):
        """Test the equality operator."""
        callables = [MagicMock(), MagicMock(), MagicMock()]

        mock_callables.return_value = callables
        mock_name.return_value = "name1"
        mock_priority.return_value = 3

        item1 = ht.events.item.HoudiniEventItem(None, None, None, None)

        item2 = MagicMock(spec=ht.events.item.HoudiniEventItem)
        item2.callables = []
        item2.name = "name2"
        item2.priority = 4

        # Names differ
        self.assertFalse(item1.__eq__(item2))

        mock_name.return_value = "name"
        item2.name = "name"

        # Names the same, callables differ
        self.assertFalse(item1.__eq__(item2))

        item2.callables = callables

        # Names and callables equal, priority differs
        self.assertFalse(item1.__eq__(item2))

        item2.priority = 3

        # Should be equal now
        self.assertEqual(item1, item2)
Пример #10
0
    def test_multiple_notifies_single_change(self):
        block_1 = MagicMock(
            to_dict=MagicMock(return_value={"attr": "initial_value"}))
        block_1.name = "block_1"
        block_2 = MagicMock(
            to_dict=MagicMock(return_value={"attr2": "initial_value"}))
        block_2.name = "block_2"
        sub_1 = MagicMock()
        sub_1.endpoint = ["block_1"]
        sub_1.delta = False
        sub_2 = MagicMock()
        sub_2.endpoint = ["block_1"]
        sub_2.delta = True
        sub_3 = MagicMock()
        sub_3.endpoint = ["block_2"]
        sub_3.delta = False
        sub_4 = MagicMock()
        sub_4.endpoint = ["block_2"]
        sub_4.delta = True
        change_1 = [["block_1", "attr"], "final_value"]
        change_2 = [["block_2", "attr2"], "final_value"]
        request_1 = BlockNotify("block_1")
        request_2 = BlockChanged(change_1)
        request_3 = BlockChanged(change_2)
        request_4 = BlockNotify("block_1")
        request_5 = BlockNotify("block_1")
        request_6 = BlockNotify("block_2")
        p = Process("proc", MagicMock())
        p.q.get = MagicMock(side_effect=[request_1, request_2, request_3,
                                         request_4, request_5, request_6,
                                         PROCESS_STOP])
        p.q.put = MagicMock(side_effect=p.q.put)
        p._subscriptions["block_1"] = [sub_1, sub_2]
        p._subscriptions["block_2"] = [sub_3, sub_4]
        p._handle_block_add(BlockAdd(block_1))
        p._handle_block_add(BlockAdd(block_2))

        p.recv_loop()

        call_list = sub_1.response_queue.put.call_args_list
        self.assertEquals(1, len(call_list))
        self.assertIsInstance(call_list[0][0][0], Update)
        self.assertEquals({"attr": "final_value"}, call_list[0][0][0].value)

        call_list = sub_2.response_queue.put.call_args_list
        self.assertEquals(1, len(call_list))
        self.assertIsInstance(call_list[0][0][0], Delta)
        self.assertEquals([[["attr"], "final_value"]],
                          call_list[0][0][0].changes)

        call_list = sub_3.response_queue.put.call_args_list
        self.assertEquals(1, len(call_list))
        self.assertIsInstance(call_list[0][0][0], Update)
        self.assertEquals({"attr2": "final_value"}, call_list[0][0][0].value)

        call_list = sub_4.response_queue.put.call_args_list
        self.assertEquals(1, len(call_list))
        self.assertIsInstance(call_list[0][0][0], Delta)
        self.assertEquals([[["attr2"], "final_value"]],
                          call_list[0][0][0].changes)
Пример #11
0
    def test_create_user_case_sensitivity(self, KeystoneManager):
        """ Test case sensitivity of check for existence in
            the user creation process """
        mock_keystone = MagicMock()
        KeystoneManager.return_value = mock_keystone

        mock_user = MagicMock()
        mock_keystone.resolve_user_id.return_value = mock_user
        mock_keystone.api.users.list.return_value = [mock_user]

        # User found is the same i.e. userA == userA
        mock_user.name = 'userA'
        utils.create_user('userA', 'passA')
        mock_keystone.resolve_user_id.assert_called_with('userA',
                                                         user_domain=None)
        mock_keystone.create_user.assert_not_called()

        # User found has different case but is the same
        # i.e. Usera != userA
        mock_user.name = 'Usera'
        utils.create_user('userA', 'passA')
        mock_keystone.resolve_user_id.assert_called_with('userA',
                                                         user_domain=None)
        mock_keystone.create_user.assert_not_called()

        # User is different i.e. UserB != userA
        mock_user.name = 'UserB'
        utils.create_user('userA', 'passA')
        mock_keystone.resolve_user_id.assert_called_with('userA',
                                                         user_domain=None)
        mock_keystone.create_user.assert_called_with(name='userA',
                                                     password='******',
                                                     tenant_id=None,
                                                     domain_id=None,
                                                     email='juju@localhost')
Пример #12
0
    def test_returns_dict(self, _):
        e1 = MagicMock()
        e1.name = "one"
        a1 = OrderedDict()
        e1.to_dict.return_value = a1
        e2 = MagicMock()
        e2.name = "two"
        a2 = OrderedDict()
        e2.to_dict.return_value = a2

        self.meta_map = MapMeta("Test")
        self.meta_map.add_element(e1, required=True)
        self.meta_map.add_element(e2, required=False)

        expected_elements_dict = OrderedDict()
        expected_elements_dict['one'] = a1
        expected_elements_dict['two'] = a2

        expected_dict = OrderedDict()
        expected_dict['elements'] = expected_elements_dict
        expected_dict['required'] = ["one"]

        response = self.meta_map.to_dict()

        self.assertEqual(expected_dict, response)
Пример #13
0
  def test_it_should_add_a_new_user_to_repo_if_is_valid(self):
    mocked_repo = MagicMock()
    mocked_repository = MagicMock()
    mocked_user = MagicMock()

    mock_single_user = MagicMock()
    mock_single_user.name = 'another_user'
    mock_single_user.__str__ = lambda x: 'another_user'

    mocked_repository.name = 'test_repo'
    mocked_repository.path = 'path'

    mocked_user.get.return_value = mock_single_user
    mocked_repo.users = ['user']

    with patch.multiple('models.lists.users',
                        Repo=MagicMock(return_value=mocked_repo),
                        User=mocked_user):
      repo_users = ListUsers(mocked_repository)
      repo_users.add('test', 'RW+')

      content = '    RW+     =    another_user\n'
      mocked_repo.write.assert_called_once_with(content)

      message = 'User another_user added to repo test_repo ' \
                'with permissions: RW+'
      mocked_repository.git.commit.has_calls([call(['conf'], message)])
Пример #14
0
 def test_modified_3_cycle_throws_circ_dependencies_error(self):
     """
     Ensures
         o   o
          \ / \
           o - o
           (right triangle is a 3 cycle)
     throws circular dependency error
     """
     stack1 = MagicMock(Spec=Stack)
     stack2 = MagicMock(Spec=Stack)
     stack3 = MagicMock(Spec=Stack)
     stack4 = MagicMock(Spec=Stack)
     stack1.dependencies = ["stack2"]
     stack1.name = "stack1"
     stack2.dependencies = ["stack3"]
     stack2.name = "stack2"
     stack3.dependencies = ["stack4"]
     stack3.name = "stack3"
     stack4.dependencies = ["stack2"]
     stack4.name = "stack4"
     stacks = {
         "stack1": stack1,
         "stack2": stack2,
         "stack3": stack3,
         "stack4": stack4
     }
     self.environment.stacks = stacks
     with pytest.raises(CircularDependenciesError) as ex:
         self.environment._check_for_circular_dependencies()
     assert (all(x in str(ex) for x in ['stack4', 'stack3', 'stack2']) and
             'stack1' not in str(ex))
Пример #15
0
    def test_validate_commit_path_with_more_than_one_entry(self):
        mocked_repo = MagicMock()
        mocked_commit = MagicMock()
        mocked_entry = MagicMock()
        mocked_second_entry = MagicMock()

        mocked_commit.tree = "tree"
        mocked_repo.revparse_single.return_value = mocked_commit

        mocked_second_entry.id = 1
        mocked_second_entry.name = "complex_entry"
        mocked_second_entry.filemode = GIT_FILEMODE_TREE
        mocked_entry.name = "simple_entry"
        mocked_entry.filemode = GIT_FILEMODE_TREE

        mocked_repo.__getitem__.return_value = [mocked_entry]

        view = CommitView(repo=mocked_repo, commit_sha1="sha1",
                          mount_time="now", uid=1, gid=1)
        result = view._validate_commit_path([mocked_second_entry,
                                             mocked_entry],
                                            ["complex_entry",
                                             "simple_entry"])
        assert result is True
        mocked_repo.__getitem__.assert_called_once_with(1)
Пример #16
0
def test_print_auto(monkeypatch):
    images = [MagicMock(name='Taupage-AMI-123', id='ami-123')]

    zone = MagicMock()
    zone.name = 'zo.ne'
    cert = {'server_certificate_name': 'zo-ne', 'arn': 'arn:aws:123'}
    cert_response = {
        'list_server_certificates_response': {'list_server_certificates_result': {'server_certificate_metadata_list': [
            cert
        ]}}}

    sg = MagicMock()
    sg.name = 'app-sg'
    sg.id = 'sg-007'

    monkeypatch.setattr('boto.cloudformation.connect_to_region', lambda x: MagicMock())
    monkeypatch.setattr('boto.vpc.connect_to_region', lambda x: MagicMock())
    monkeypatch.setattr('boto.iam.connect_to_region', lambda x: MagicMock(list_server_certs=lambda: cert_response))
    monkeypatch.setattr('boto.route53.connect_to_region', lambda x: MagicMock(get_zones=lambda: [zone]))
    monkeypatch.setattr('boto.ec2.connect_to_region', lambda x: MagicMock(get_all_images=lambda filters: images,
                                                                          get_all_security_groups=lambda: [sg]))

    sns = MagicMock()
    topic = {'TopicArn': 'arn:123:mytopic'}
    sns.get_all_topics.return_value = {'ListTopicsResponse': {'ListTopicsResult': {'Topics': [topic]}}}
    monkeypatch.setattr('boto.sns.connect_to_region', MagicMock(return_value=sns))

    data = {'SenzaInfo': {'StackName': 'test',
                          'OperatorTopicId': 'mytopic',
                          'Parameters': [{'ImageVersion': {'Description': ''}}]},
            'SenzaComponents': [{'Configuration': {'Type': 'Senza::StupsAutoConfiguration'}},
                                {'AppServer': {'Type': 'Senza::TaupageAutoScalingGroup',
                                               'ElasticLoadBalancer': 'AppLoadBalancer',
                                               'InstanceType': 't2.micro',
                                               'TaupageConfig': {'runtime': 'Docker',
                                                                 'source': 'foo/bar:{{Arguments.ImageVersion}}'},
                                               'IamRoles': ['app-myrole'],
                                               'SecurityGroups': ['app-sg', 'sg-123'],
                                               'AutoScaling':
                                                   {'Minimum': 1,
                                                    'Maximum': 10,
                                                    'MetricType': 'CPU'}}},
                                {'AppLoadBalancer': {'Type': 'Senza::WeightedDnsElasticLoadBalancer',
                                                     'HTTPPort': 8080,
                                                     'SecurityGroups': ['app-sg']}}]}

    runner = CliRunner()

    with runner.isolated_filesystem():
        with open('myapp.yaml', 'w') as fd:
            yaml.dump(data, fd)

        result = runner.invoke(cli, ['print', 'myapp.yaml', '--region=myregion', '123', '1.0-SNAPSHOT'],
                               catch_exceptions=False)

    assert 'AWSTemplateFormatVersion' in result.output
    assert 'subnet-123' in result.output
    assert 'source: foo/bar:1.0-SNAPSHOT' in result.output
    assert '"HealthCheckType": "ELB"' in result.output
Пример #17
0
def createOperationsMock():
  """ create an Mock for the Operations Helper """
  opModuleMock = Mock()
  opModuleMock.name = "OperationsModule Mock"
  opMock = Mock()
  opModuleMock.return_value = opMock
  opMock.name = "OperationsClass Mock"

  opMock.getOptionsDict.side_effect = getOptionsDictMock
  return opModuleMock
Пример #18
0
    def test_20_launch(self, get_driver):
        radl_data = """
            network net1 (outbound = 'yes')
            network net2 ()
            system test (
            cpu.arch='x86_64' and
            cpu.count=1 and
            memory.size=512m and
            net_interface.0.connection = 'net1' and
            net_interface.0.dns_name = 'test' and
            net_interface.1.connection = 'net2' and
            disk.0.os.name = 'linux' and
            disk.0.image.url = 'aws://ami-id' and
            disk.0.os.credentials.username = '******' and
            disk.1.size=1GB and
            disk.1.device='hdb' and
            disk.1.mount_path='/mnt/path'
            )"""
        radl = radl_parse.parse_radl(radl_data)
        radl.check()

        auth = Authentication([{'id': 'libcloud', 'type': 'LibCloud', 'username': '******',
                                'password': '******', 'driver': 'EC2'}])
        lib_cloud = self.get_lib_cloud()

        driver = MagicMock()
        driver.name = "Amazon EC2"
        driver.features = {"create_node": ["ssh_key"]}
        get_driver.return_value = driver

        node_size = MagicMock()
        node_size.ram = 512
        node_size.price = 1
        node_size.disk = 1
        node_size.vcpus = 1
        node_size.name = "small"
        driver.list_sizes.return_value = [node_size]

        driver.get_key_pair.return_value = ""

        keypair = MagicMock()
        keypair.public_key = "public"
        driver.create_key_pair.return_value = keypair
        driver.features = {'create_node': ['ssh_key']}

        node = MagicMock()
        node.id = "1"
        node.name = "name"
        driver.create_node.return_value = node

        res = lib_cloud.launch(InfrastructureInfo(), radl, radl, 1, auth)
        success, _ = res[0]
        self.assertTrue(success, msg="ERROR: launching a VM.")
        self.assertNotIn("ERROR", self.log.getvalue(), msg="ERROR found in log: %s" % self.log.getvalue())
        self.clean_log()
Пример #19
0
    def test_tranformer(self):
        status = rd_instance.ServiceStatuses.BUILDING.api_status
        db_instance = MockMgmtInstanceTest.build_db_instance(
            status, task_status=InstanceTasks.BUILDING)

        stub_dsv_db_info = MagicMock(spec=datastore_models.DBDatastoreVersion)
        stub_dsv_db_info.id = "test_datastore_version"
        stub_dsv_db_info.datastore_id = "mysql_test_version"
        stub_dsv_db_info.name = "test_datastore_name"
        stub_dsv_db_info.image_id = "test_datastore_image_id"
        stub_dsv_db_info.packages = "test_datastore_pacakges"
        stub_dsv_db_info.active = 1
        stub_dsv_db_info.manager = "mysql"
        stub_datastore_version = datastore_models.DatastoreVersion(
            stub_dsv_db_info)

        flavor = MagicMock(spec=Flavor)
        flavor.name = 'db.small'

        server = MagicMock(spec=Server)
        server.user_id = 'test_user_id'
        mgmt_instance = mgmtmodels.SimpleMgmtInstance(self.context,
                                                      db_instance,
                                                      server,
                                                      None)

        with patch.object(DatabaseModelBase, 'find_by',
                          return_value=stub_datastore_version):

            with patch.object(mgmtmodels, 'load_mgmt_instances',
                              return_value=[mgmt_instance]):

                with patch.object(self.flavor_mgr, 'get', return_value=flavor):

                    # invocation
                    transformer = mgmtmodels.NovaNotificationTransformer(
                        context=self.context)
                    payloads = transformer()

                    # assertions
                    self.assertIsNotNone(payloads)
                    self.assertThat(len(payloads), Equals(1))
                    payload = payloads[0]
                    self.assertThat(payload['audit_period_beginning'],
                                    Not(Is(None)))
                    self.assertThat(payload['audit_period_ending'],
                                    Not(Is(None)))
                    self.assertThat(payload['state'], Equals(status.lower()))
                    self.assertThat(payload['instance_type'],
                                    Equals('db.small'))
                    self.assertThat(payload['instance_type_id'],
                                    Equals('flavor_1'))
                    self.assertThat(payload['user_id'], Equals('test_user_id'))
                    self.assertThat(payload['service_id'], Equals('123'))
Пример #20
0
 def test018_update_ref_no_prev(self):
     m_fw, m_file, m_pr = MagicMock(), MagicMock(), MagicMock()
     m_probe = MagicMock()
     probe = MagicMock()
     probename = "probe1"
     probe.name = probename
     m_probe.name = probe
     m_file.ref_results = []
     m_pr.name = "probe2"
     module._update_ref_results(m_fw, m_file, m_pr)
     self.assertItemsEqual(m_file.ref_results, [m_pr])
Пример #21
0
    def test___eq__(self, mock_name_prop):
        """Test the equality operator."""
        rule = styles.StyleRule(None, None, None, None)

        mock_rule = MagicMock(spec=styles.StyleRule)
        mock_rule.name = "different_name"

        self.assertNotEqual(rule, mock_rule)

        mock_rule.name = "name"
        self.assertEqual(rule, mock_rule)
Пример #22
0
 def test_modx_dispatch(self):
     self.assertRaises(Http404, render.modx_dispatch, 'dummy', 'dummy',
                       'invalid Location', 'dummy')
     mock_request = MagicMock()
     mock_request.FILES.keys.return_value = ['file_id']
     mock_request.FILES.getlist.return_value = ['file'] * (settings.MAX_FILEUPLOADS_PER_INPUT + 1)
     self.assertEquals(render.modx_dispatch(mock_request, 'dummy', self.location, 'dummy').content,
                       json.dumps({'success': 'Submission aborted! Maximum %d files may be submitted at once' %
                                   settings.MAX_FILEUPLOADS_PER_INPUT}))
     mock_request_2 = MagicMock()
     mock_request_2.FILES.keys.return_value = ['file_id']
     inputfile = MagicMock()
     inputfile.size = 1 + settings.STUDENT_FILEUPLOAD_MAX_SIZE
     inputfile.name = 'name'
     filelist = [inputfile]
     mock_request_2.FILES.getlist.return_value = filelist
     self.assertEquals(render.modx_dispatch(mock_request_2, 'dummy', self.location,
                                            'dummy').content,
                       json.dumps({'success': 'Submission aborted! Your file "%s" is too large (max size: %d MB)' %
                                   (inputfile.name, settings.STUDENT_FILEUPLOAD_MAX_SIZE / (1000 ** 2))}))
     mock_request_3 = MagicMock()
     mock_request_3.POST.copy.return_value = {'position': 1}
     mock_request_3.FILES = False
     mock_request_3.user = self.mock_user
     inputfile_2 = MagicMock()
     inputfile_2.size = 1
     inputfile_2.name = 'name'
     self.assertIsInstance(render.modx_dispatch(mock_request_3, 'goto_position',
                                                self.location, self.course_id), HttpResponse)
     self.assertRaises(
         Http404,
         render.modx_dispatch,
         mock_request_3,
         'goto_position',
         self.location,
         'bad_course_id'
     )
     self.assertRaises(
         Http404,
         render.modx_dispatch,
         mock_request_3,
         'goto_position',
         ['i4x', 'edX', 'toy', 'chapter', 'bad_location'],
         self.course_id
     )
     self.assertRaises(
         Http404,
         render.modx_dispatch,
         mock_request_3,
         'bad_dispatch',
         self.location,
         self.course_id
     )
Пример #23
0
 def test020_update_ref_error(self, m_log):
     m_fw, m_file, m_pr = MagicMock(), MagicMock(), MagicMock()
     m_probe = MagicMock()
     probe = MagicMock()
     probename = "probe1"
     probe.name = probename
     m_probe.name = probe
     m_pr.name = "probe1"
     m_file.ref_results = [m_pr, m_pr]
     module._update_ref_results(m_fw, m_file, m_pr)
     self.assertItemsEqual(m_file.ref_results, [m_pr, m_pr])
     m_log.error.called_once()
Пример #24
0
    def test_20_launch(self, get_driver):
        radl_data = """
            network net1 (outbound = 'yes')
            network net2 ()
            system test (
            cpu.arch='x86_64' and
            cpu.count=1 and
            memory.size=512m and
            net_interface.0.connection = 'net1' and
            net_interface.0.ip = '10.0.0.1' and
            net_interface.0.dns_name = 'test' and
            net_interface.1.connection = 'net2' and
            disk.0.os.name = 'linux' and
            disk.0.image.url = 'gce://us-central1-a/centos-6' and
            disk.0.os.credentials.username = '******' and
            disk.1.size=1GB and
            disk.1.device='hdb' and
            disk.1.mount_path='/mnt/path'
            )"""
        radl = radl_parse.parse_radl(radl_data)
        radl.check()

        auth = Authentication([{'id': 'one', 'type': 'GCE', 'username': '******',
                                'password': '******', 'project': 'proj'}])
        gce_cloud = self.get_gce_cloud()

        driver = MagicMock()
        get_driver.return_value = driver

        node_size = MagicMock()
        node_size.ram = 512
        node_size.price = 1
        node_size.disk = 1
        node_size.vcpus = 1
        node_size.name = "small"
        driver.list_sizes.return_value = [node_size]

        driver.ex_get_image.return_value = "image"
        driver.ex_create_address.return_value = "ip"
        net = MagicMock()
        net.name = "default"
        driver.ex_list_networks.return_value = [net]

        node = MagicMock()
        node.id = "gce1"
        node.name = "gce1name"
        driver.create_node.return_value = node

        res = gce_cloud.launch(InfrastructureInfo(), radl, radl, 1, auth)
        success, _ = res[0]
        self.assertTrue(success, msg="ERROR: launching a VM.")
        self.assertNotIn("ERROR", self.log.getvalue(), msg="ERROR found in log: %s" % self.log.getvalue())
        self.clean_log()
Пример #25
0
 def test019_update_ref_prev(self):
     m_fw, m_file = MagicMock(), MagicMock()
     m_pr_new, m_pr_old = MagicMock(), MagicMock()
     m_probe = MagicMock()
     probe = MagicMock()
     probename = "probe1"
     probe.name = probename
     m_probe.name = probe
     m_pr_old.name = "probe1"
     m_pr_new.name = "probe1"
     m_file.ref_results = [m_pr_old]
     module._update_ref_results(m_fw, m_file, m_pr_new)
     self.assertItemsEqual(m_file.ref_results, [m_pr_new])
 def cache_get(package):
     pkg = MagicMock()
     if package in self.fake_repo \
             and 'pkg_vers' in self.fake_repo[package]:
         pkg.name = package
         pkg.current_ver.ver_str = self.fake_repo[package]['pkg_vers']
     elif (package in self.fake_repo and
           'pkg_vers' not in self.fake_repo[package]):
         pkg.name = package
         pkg.current_ver = None
     else:
         raise KeyError
     return pkg
Пример #27
0
    def test_loop(self):
        group1 = MagicMock()
        group1.name = "group1"
        group2 = MagicMock()
        group2.name = "group2"
        group3 = MagicMock()
        group3.name = "group3"

        group3.subgroups = [group2]
        group2.subgroups = [group1]
        group1.subgroups = [group3]

        with self.assertRaises(RuntimeError):
            _flatten_group_hierarchy([group1, group2, group3])
Пример #28
0
 def test_no_circular_dependencies_throws_no_error(self):
     stack1 = MagicMock(Spec=Stack)
     stack2 = MagicMock(Spec=Stack)
     stack1.dependencies = ["stack2"]
     stack1.name = "stack1"
     stack2.dependencies = []
     stack2.name = "stack2"
     stacks = {
         "stack1": stack1,
         "stack2": stack2
     }
     self.environment.stacks = stacks
     # Check this runs without throwing an exception
     self.environment._check_for_circular_dependencies()
Пример #29
0
    def setUp(self):
        # Mock resource model
        resource1 = MagicMock()
        resource1.name = 'Resource1'
        resource1.version = '1.0'
        resource1.description = 'Test resource 1'
        resource1.content_type = 'text/plain'
        resource1.state = 'created'
        resource1.open = False
        resource1.get_url.return_value = 'http://localhost/media/resources/resource1'

        resource2 = MagicMock()
        resource2.name = 'Resource2'
        resource2.version = '2.0'
        resource2.description = 'Test resource 2'
        resource2.content_type = 'text/plain'
        resource2.state = 'created'
        resource2.open = False
        resource2.get_url.return_value = 'http://localhost/media/resources/resource2'

        resource3 = MagicMock()
        resource3.name = 'Resource3'
        resource3.version = '2.0'
        resource3.description = 'Test resource 3'
        resource3.content_type = 'text/plain'
        resource3.state = 'created'
        resource3.open = True
        resource3.get_url.return_value = 'http://localhost/media/resources/resource3'

        resource4 = MagicMock()
        resource4.name = 'Resource4'
        resource4.version = '1.0'
        resource4.description = 'Test resource 4'
        resource4.content_type = 'text/plain'
        resource4.state = 'created'
        resource4.open = True
        resource4.get_url.return_value = 'http://localhost/media/resources/resource4'
        resource4.offerings = ['1111', '2222']

        resources_management.Resource = MagicMock()
        resources_management.Resource.objects.filter.return_value = [
            resource1,
            resource2,
            resource3,
            resource4
        ]
        self.user = MagicMock()
        self.org = MagicMock()
        self.user.userprofile.current_organization = self.org
Пример #30
0
def test_chute_storage(mSave):

    #Test setAttr & getAttr
    s = chute_storage.ChuteStorage()
    assert s.chuteList == {}
    s.setAttr('test')
    assert s.chuteList == 'test'
    ch2 = MagicMock()
    s.setAttr({1: 'ch1', 2: ch2 , 3: 'ch3'})
    for ch in ['ch1', ch2, 'ch3']:
        assert ch in s.getChuteList()
    assert s.getAttr() == {1: 'ch1', 2: ch2, 3: 'ch3'}
    assert s.attrSaveable()

    #Test saveChute
    ch = MagicMock()
    ch.name = 'ch1'
    s.saveChute(ch)
    mSave.assert_called_once_with()
    mSave.reset_mock()
    ch.name = 2
    s.saveChute(ch)
    mSave.assert_called_once_with()

    #Test deleteChute
    ch = Chute({})
    assert not ch.isValid()
    mSave.reset_mock()
    ch.name = 'test'
    s.saveChute(ch)
    mSave.assert_called_once_with()
    assert ch in s.getChuteList()
    mSave.reset_mock()
    s.deleteChute(ch)
    mSave.assert_called_once_with()
    assert ch not in s.getChuteList()
    mSave.assert_called_once_with()
    assert 'ch1' in s.getChuteList()
    mSave.reset_mock()
    s.deleteChute(1)
    mSave.assert_called_once_with()
    assert 'ch1' not in s.getChuteList()

    #Test clearChuteStorage
    assert s.getChuteList != []
    mSave.reset_mock()
    s.clearChuteStorage()
    mSave.assert_called_once_with()
    assert s.getChuteList() == []
Пример #31
0
    def test_add_tasks_unknow_type(self, find_mock):
        """Test add_tasks with unknown type works."""
        project = MagicMock()
        project.name = 'name'
        project.short_name = 'short_name'
        project.description = 'description'
        project.info = dict()

        find_mock.return_value = project

        tasks = MagicMock()
        tasks.read.return_value = "key, value\n, 1, 2"

        pbclient = MagicMock()
        pbclient.create_task.return_value = {'id': 1, 'info': {'key': 'value'}}
        self.config.pbclient = pbclient
        res = _add_tasks(self.config, tasks, 'doc', 0, 30)
        assert res == ("Unknown format for the tasks file. Use json, csv, po or "
                      "properties."), res
Пример #32
0
    def test_add_onesignal_event(self, mock_onesignal):
        """Test add_onesignal_app is called."""
        from pybossa.jobs import create_onesignal_app
        conn = MagicMock()
        target = MagicMock()
        tmp = Project(id=1, name='name', short_name='short_name',
                      info=dict(container=1, thumbnail="avatar.png"))
        target.id = tmp.id
        target.project_id = tmp.id
        target.name = tmp.name
        target.short_name = tmp.short_name
        target.info = tmp.info

        conn.execute.return_value = [tmp]
        add_onesignal_app(None, conn, target)
        assert mock_onesignal.called
        obj = tmp.to_public_json()
        obj['action_updated'] = 'Project'
        mock_onesignal.assert_called_with(create_onesignal_app, target.id)
Пример #33
0
    def test_add_tasks_csv_with_info(self, find_mock):
        """Test add_tasks csv with info field works."""
        project = MagicMock()
        project.name = 'name'
        project.short_name = 'short_name'
        project.description = 'description'
        project.info = dict()

        find_mock.return_value = project

        tasks = MagicMock()
        tasks.read.return_value = "info, value\n, %s, 2" % json.dumps(
            {'key': 'value'})

        pbclient = MagicMock()
        pbclient.create_task.return_value = {'id': 1, 'info': {'key': 'value'}}
        self.config.pbclient = pbclient
        res = _add_tasks(self.config, tasks, 'csv', 0, 30)
        assert res == '1 tasks added to project: short_name', res
Пример #34
0
 def test_get_site_images(self, get_driver, getCachedSiteList):
     cred = MagicMock()
     cred.get_cred.return_value = {"project": "project_name"}
     getCachedSiteList.return_value = {
         'CESGA': {
             'url': 'https://fedcloud-osservices.egi.cesga.es:5000',
             'state': '',
             'id': '11548G0'
         }
     }
     driver = MagicMock()
     get_driver.return_value = driver
     image1 = MagicMock()
     image1.id = "imageid1"
     image1.name = "imagename1"
     driver.list_images.return_value = [image1]
     res = utils.get_site_images("CESGA", "vo.access.egi.eu", "token", cred,
                                 "user")
     self.assertEquals(res, [('imagename1', 'imageid1')])
def test_beacon_change():
    '''
    Test beacon functionality. Another run with cache file.
    There are changes so it should report the new values.
    '''
    domain = MagicMock()
    domain.info = MagicMock(name='info')
    domain.info.return_value = [4, 1024, 2048, 2, 30]
    domain.name = MagicMock(name='name')
    domain.name.return_value = 'testvm'

    conn = MagicMock()
    conn.listAllDomains = MagicMock(name='listAllDomains')
    conn.listAllDomains.return_value = [domain]

    if os.path.exists(CACHE_FILE):
        os.unlink(CACHE_FILE)
    shutil.copyfile(
        os.path.sep.join(
            [os.path.abspath(''), 'data', 'virt_state-test.initcache']),
        CACHE_FILE)

    with patch.object(virtpoller, 'libvirt', MagicMock(return_value=True)):
        with patch.object(virtpoller.libvirt, 'openReadOnly',
                          MagicMock(return_value=conn)):
            with patch.object(virtpoller.binascii, 'hexlify',
                              MagicMock(return_value=5)):
                ret = virtpoller.beacon({
                    'cache_file': CACHE_FILE,
                    'expire_time': 2
                })
    assert isinstance(ret, list)
    assert isinstance(ret[0], dict)
    assert sorted(ret[0].keys()) == ['plan']
    assert ret[0]['plan'][0]['event_type'] == 'exists'
    assert 'guest_properties' in ret[0]['plan'][0]
    data = ret[0]['plan'][0]['guest_properties']
    assert data['name'] == 'testvm'
    assert data['virt_type'] == 'para_virtualized'
    assert data['state'] == 'stopped'
    assert data['vcpus'] == 2
    assert data['memory_size'] == '2048'
    assert data['uuid'] == 5
Пример #36
0
def test_add_node_stopped_metric(node_scenario):
    node_scenario.schema = {
        "actions": [
            {
                "stop": {}
            },
        ],
    }

    mock_item = MagicMock()
    mock_item.uid = '1'
    mock_item.name = 'node1'
    items = [mock_item]

    with mock.patch('powerfulseal.metriccollectors.StdoutCollector.add_node_stopped_metric') \
            as metric_function:
        metric_function.assert_not_called()
        node_scenario.act(items)
        metric_function.assert_called_once_with(mock_item)
Пример #37
0
    def test_60_finalize(self, sleep, get_driver):
        auth = Authentication([{
            'id': 'one',
            'type': 'GCE',
            'username': '******',
            'password': '******',
            'project': 'proj'
        }])
        gce_cloud = self.get_gce_cloud()

        radl_data = """
            system test (
            cpu.count>=2 and
            memory.size>=2048m
            )"""
        radl = radl_parse.parse_radl(radl_data)

        inf = MagicMock()
        inf.get_next_vm_id.return_value = 1
        vm = VirtualMachine(inf, "1", gce_cloud.cloud, radl, radl, gce_cloud)

        driver = MagicMock()
        driver.name = "OpenStack"
        get_driver.return_value = driver

        node = MagicMock()
        node.destroy.return_value = True
        node.extra = {'disks': [{'source': 'vol'}]}
        node.driver = driver
        driver.ex_get_node.return_value = node

        volume = MagicMock()
        volume.detach.return_value = True
        volume.destroy.return_value = True
        driver.ex_get_volume.return_value = volume

        success, _ = gce_cloud.finalize(vm, auth)

        self.assertTrue(success, msg="ERROR: finalizing VM info.")
        self.assertNotIn("ERROR",
                         self.log.getvalue(),
                         msg="ERROR found in log: %s" % self.log.getvalue())
        self.clean_log()
Пример #38
0
    def test_readdir_with_tree_name(self):
        mocked_repo = MagicMock()
        mocked_commit = MagicMock()
        mocked_entry = MagicMock()

        mocked_entry.name = "entry"
        mocked_commit.tree = "tree"
        mocked_repo.revparse_single.return_value = mocked_commit
        mocked_repo.get_git_object.return_value = [mocked_entry]

        view = CommitView(repo=mocked_repo, commit_sha1="sha1")
        with patch("gitfs.views.commit.os") as mocked_os:
            mocked_os.path.split.return_value = [None, True]

            dirs = [entry for entry in view.readdir("/path", 0)]
            assert dirs == [".", "..", "entry"]

            mocked_os.path.split.assert_called_once_with("/path")
            mocked_repo.get_git_object.assert_called_once_with("tree", "/path")
Пример #39
0
    def create_fake_import(self,
                           name,
                           version='1',
                           check_items=True,
                           install_status=InstallationStatuses.INSTALL_OK,
                           uninstall_status=InstallationStatuses.UNINSTALL_OK):
        filenames = []
        filenames.append('%s.py' % FAKE_NAME1)

        import_mock = MagicMock()
        fake_package = MagicMock()
        fake_package.name = name
        fake_package.version = version
        fake_package.check_items.return_value = check_items
        fake_package.install.return_value = install_status
        fake_package.uninstall.return_value = uninstall_status
        import_mock.Formula.return_value = fake_package

        return filenames, import_mock
Пример #40
0
    def setUp(self):
        # Build resource mock
        self.resource = MagicMock()
        self.resource.name = 'test_resource'
        org = MagicMock()
        org.name = 'test_org'
        self.resource.provider = org
        self.resource.download_link = ''
        self.resource.resource_path = '/media/resources/test_res1.0.rdf'
        self.resource.resource_type = 'Downloadable'
        self.resource.version = '0.1'
        self.resource.old_versions = []
        resources_management._upload_usdl = MagicMock(name="_upload_usdl")

        # Mock context
        context_obj = MagicMock()
        context_obj.site.domain = 'http://localhost'
        resources_management.Context = MagicMock(name="Context")
        resources_management.Context.objects.all.return_value = [context_obj]
Пример #41
0
 def test_fallback_packages_redirect(self):
     """ Fetch fallback packages with redirect URLs """
     self.request.locator = MagicMock()
     version = "1.1"
     name = "foo"
     filename = "%s-%s.tar.gz" % (name, version)
     url = "https://pypi.org/pypi/%s/%s" % (name, filename)
     wheelname = "%s-%s.whl" % (name, version)
     wheel_url = "https://pypi.org/pypi/%s/%s" % (name, wheelname)
     dist = MagicMock()
     dist.name = name
     self.request.locator.get_project.return_value = {
         version: dist,
         "urls": {
             version: [url, wheel_url]
         },
     }
     pkgs = get_fallback_packages(self.request, "foo")
     self.assertEqual(pkgs, {filename: url, wheelname: wheel_url})
Пример #42
0
    def test_search_vm(self, soapproxy):
        proxy = MagicMock()
        vmrc_res = MagicMock()
        vmrc_res.name = "Image"
        vmrc_res.hypervisor = "qemu"
        vmrc_res.userPassword = "******"
        vmrc_res.userLogin = "******"
        vmrc_res.os = MagicMock()
        vmrc_res.os.name = "linux"
        vmrc_res.os.flavour = "ubuntu"
        vmrc_res.os.version = "14.04"
        vmrc_res.location = "one://server.com/1"
        proxy.search.return_value = [vmrc_res]
        soapproxy.return_value = proxy

        vmrc = VMRC("http://host:8080/vmrc/vmrc", "user", "pass")

        radl_data = """
            network net ()
            system test (
            cpu.arch='x86_64' and
            cpu.count>=1 and
            memory.size>=512m and
            net_interface.0.connection = 'net' and
            disk.0.os.flavour='ubuntu' and
            disk.0.os.version>='12.04' and
            disk.applications contains (name = 'app' and version = '1.0') and
            soft 10 (disk.applications contains (name = 'otherapp' and version = '2.0'))
            )

            deploy test 1
            """
        radl = radl_parse.parse_radl(radl_data)

        res_radl = vmrc.search_vm(radl.systems[0])
        self.assertEqual(len(res_radl), 1)
        self.assertEqual(res_radl[0].getValue("disk.0.image.url"),
                         "one://server.com/1")
        self.assertEqual(
            res_radl[0].getValue("disk.0.os.credentials.password"), "pass")
        self.assertEqual(
            res_radl[0].getValue("disk.0.os.credentials.username"), "user")
Пример #43
0
    def test_consume_with_exception(self, mock_producer, mock_warced_class):

        mock_connection = MagicMock(spec=Connection)
        mock_exchange = MagicMock(spec=Exchange)
        mock_exchange.name = "test exchange"
        mock_warced = MagicMock(spec=warced)
        mock_warced_class.return_value = mock_warced
        mock_message = MagicMock(spec=Message)
        mock_message.delivery_info = {
            "routing_key": "harvest.start.test.test_usertimeline"
        }

        # Create harvester and invoke _callback
        harvester = TestableHarvester(self.working_path,
                                      mock_connection,
                                      mock_exchange,
                                      raise_exception_on_count=[1, 2],
                                      tries=2)
        harvester._callback(self.message, mock_message)

        # Test assertions
        self.assertEqual(2, harvester.harvest_seed_call_count)
        self.assertEqual(0, harvester.process_warc_call_count)

        # Failed harvest result message
        self.assertEqual(4, len(mock_producer.mock_calls))
        self.assert_first_running_harvest_status(*mock_producer.mock_calls[1])
        name, _, kwargs = mock_producer.mock_calls[3]
        self.assertEqual("harvest.status.test.test_usertimeline",
                         kwargs["routing_key"])
        harvest_result_message = kwargs["body"]
        self.assertEqual(harvest_result_message["id"], "test:1")
        self.assertEqual(harvest_result_message["status"], STATUS_FAILURE)
        self.assertEqual(1, len(harvest_result_message["infos"]))
        self.assertEqual(1, len(harvest_result_message["warnings"]))
        self.assertEqual(2, len(harvest_result_message["errors"]))
        self.assertEqual(CODE_UNKNOWN_ERROR,
                         harvest_result_message["errors"][1]["code"])
        self.assertIsNotNone(
            iso8601.parse_date(harvest_result_message["date_started"]))
        self.assertIsNotNone(
            iso8601.parse_date(harvest_result_message["date_ended"]))
Пример #44
0
    def test_10_concrete(self, get_driver):
        radl_data = """
            network net ()
            system test (
            cpu.arch='x86_64' and
            cpu.count>=1 and
            memory.size>=512m and
            net_interface.0.connection = 'net' and
            net_interface.0.dns_name = 'test' and
            disk.0.os.name = 'linux' and
            disk.0.image.url = 'ost://server.com/ami-id' and
            disk.0.os.credentials.username = '******'
            )"""
        radl = radl_parse.parse_radl(radl_data)
        radl_system = radl.systems[0]

        auth = Authentication([{
            'id': 'ost',
            'type': 'OpenStack',
            'username': '******',
            'password': '******',
            'tenant': 'tenant',
            'host': 'https://server.com:5000'
        }])
        ost_cloud = self.get_ost_cloud()

        driver = MagicMock()
        get_driver.return_value = driver

        node_size = MagicMock()
        node_size.ram = 512
        node_size.price = 1
        node_size.disk = 1
        node_size.vcpus = 1
        node_size.name = "small"
        driver.list_sizes.return_value = [node_size]

        concrete = ost_cloud.concreteSystem(radl_system, auth)
        self.assertEqual(len(concrete), 1)
        self.assertNotIn("ERROR",
                         self.log.getvalue(),
                         msg="ERROR found in log: %s" % self.log.getvalue())
Пример #45
0
    def test_add_tasks_excel_with_info(self, auto_mock, find_mock,
                                       workbook_mock):
        """Test add_tasks excel with info field works."""
        auto_mock.return_value = (0, None)

        project = MagicMock()
        project.name = 'name'
        project.short_name = 'short_name'
        project.description = 'description'
        project.info = dict()
        project.id = 1

        wb = Workbook()
        ws = wb.active

        headers = ['Column Name', 'foo']
        ws.append(headers)
        for row in range(2, 10):
            ws.append(['value', 'bar'])

        ws.append([None, None])
        ws.append([None, None])

        find_mock.return_value = project

        tasks = MagicMock()
        tasks.read.return_value = wb

        workbook_mock.return_value = wb

        pbclient = MagicMock()
        self.config.pbclient = pbclient
        res = _add_tasks(self.config, tasks, 'xlsx', 0, 30)
        self.config.pbclient.create_task.assert_called_with(
            project_id=find_mock().id,
            info={
                u'column_name': u'value',
                u'foo': u'bar'
            },
            n_answers=30,
            priority_0=0)
        assert res == '8 tasks added to project: short_name', res
Пример #46
0
    def test_52_reboot(self, conn, pvim):
        auth = Authentication([{
            'id': 'vsp',
            'type': 'vSphere',
            'host': 'https://vspherehost',
            'username': '******',
            'password': '******'
        }])
        vsphere_cloud = self.get_vsphere_cloud()

        smatconn = MagicMock()
        conn.return_value = smatconn
        retcont = MagicMock()
        smatconn.RetrieveContent.return_value = retcont
        retcont.viewManager.CreateContainerView.side_effect = self.CreateContainerView
        pvim.VirtualMachine = vim.VirtualMachine

        pvim.TaskInfo.State.success = vim.TaskInfo.State.success
        pvim.Task = vim.Task
        property_collector = MagicMock()
        smatconn.content.propertyCollector = property_collector
        update = MagicMock()
        property_collector.WaitForUpdates.return_value = update
        fs = MagicMock()
        update.filterSet = [fs]
        objs = MagicMock()
        fs.objectSet = [objs]
        change = MagicMock()
        objs.changeSet = [change]
        objs.obj = vim.Task("ResetVM")
        change.name = "info.state"
        change.val = vim.TaskInfo.State.success
        inf = MagicMock()
        vm = VirtualMachine(inf, "vm-template", vsphere_cloud.cloud, "", "",
                            vsphere_cloud, 1)

        success, _ = vsphere_cloud.reboot(vm, auth)

        self.assertTrue(success, msg="ERROR: rebooting VM info.")
        self.assertNotIn("ERROR",
                         self.log.getvalue(),
                         msg="ERROR found in log: %s" % self.log.getvalue())
    def setUp(self):
        self.deck_validator = DeckValidator()
        self.empty_deck = Deck([])
        self.oversized_deck = Deck([Mock() for _ in range(60)])

        outfit = Mock()
        outfit.type = 'Outfit'
        self.multi_outfit_deck = [outfit, outfit]

        joker = Mock()
        joker.type = 'Joker'
        self.triple_joker_deck = [joker, joker, joker]

        nate_hunter = MagicMock()
        nate_hunter.type = 'Dude'
        nate_hunter.name = 'Nate Hunter'
        nate_hunter.__str__.return_value = nate_hunter.name
        self.over_four_copies_deck = [nate_hunter, nate_hunter, nate_hunter, nate_hunter, nate_hunter]

        self.really_erroneous_deck = self.multi_outfit_deck + self.triple_joker_deck + self.over_four_copies_deck
Пример #48
0
    def test_add_exists_new_network_profile_error(self, m_json):
        """
        Test add when the endpoint already exists, adding to a new
        network, error applying profile.
        """
        # Mock out apply_profile to throw error.
        self.plugin.policy_driver.apply_profile.side_effect = ApplyProfileError

        # Mock out _get_endpoint - endpoint exists.
        ip4 = IPNetwork("10.0.0.1")
        ip6 = IPNetwork("bad::beef")
        endpoint = MagicMock(spec=Endpoint)
        endpoint.ipv4_nets = [ip4]
        endpoint.ipv6_nets = [ip6]
        endpoint.name = "cali12345"
        self.plugin._get_endpoint = MagicMock(spec=self.plugin._get_endpoint)
        self.plugin._get_endpoint.return_value = endpoint

        # Call method.
        assert_raises(SystemExit, self.plugin.add)
Пример #49
0
    def test_create_type_mappings_use_default_mappings_no_story(
        self, input_mock
    ):
        self.handler.issue_types = MagicMock()

        ticket = MagicMock()
        ticket_type = "bug,ci"
        ticket.type = ticket_type
        issue_type = MagicMock()
        issue_type.name = "Bug"
        issue_types = [issue_type]

        self.handler.issue_types.return_value = issue_types

        input_mock.side_effect = ["Y"]

        mappings = self.handler.create_type_mappings([ticket])

        self.assertEqual(mappings, {"bug": "Bug", "ci": "Bug"})
        self.assertEqual(input_mock.call_count, 1)
Пример #50
0
 def test_disallow_fallback_packages(self):
     """ Disallow fetch fallback packages """
     self.request.locator = MagicMock()
     version = "1.1"
     name = "foo"
     filename = "%s-%s.tar.gz" % (name, version)
     url = "http://pypi.python.org/pypi/%s/%s" % (name, filename)
     wheelname = "%s-%s.whl" % (name, version)
     wheel_url = "http://pypi.python.org/pypi/%s/%s" % (name, wheelname)
     dist = MagicMock()
     dist.name = name
     self.request.locator.get_project.return_value = {
         version: dist,
         "urls": {
             version: [url, wheel_url]
         },
     }
     self.request.access.has_permission = MagicMock(return_value=False)
     pkgs = get_fallback_packages(self.request, "foo")
     self.assertEqual(pkgs, {})
Пример #51
0
def test_close_spider_removes_file_with_no_data(datetime_mock, exporter_mock,
                                                os_mock):
    datetime_mock.now.return_value = DATE_TIME
    os_mock.path.getsize.return_value = 0
    csvpipeline = CSVExportPipeline()
    spider_mock = Mock(spec=GlassdoorSpider)
    spider_mock.file_name = "glassdoor_spider"
    csvpipeline.exporter = exporter_mock
    csvpipeline.file_name = (
        f'{spider_mock.file_name} {DATE_TIME.strftime("%m-%d-%Y %H-%M-%S")}.csv'
    )
    os_mock.path.realpath.return_value = csvpipeline.file_name
    mock_file = MagicMock()
    with patch("builtins.open", return_value=mock_file, create=True):
        csvpipeline.file = open(csvpipeline.file_name, "wb")
        mock_file.name = csvpipeline.file_name
        close_spider_mock = Mock(side_effect=csvpipeline.close_spider)
        close_spider_mock(spider_mock)
        os_mock.path.getsize.assert_called_once_with(csvpipeline.file_name)
        os_mock.remove.assert_called_once_with(csvpipeline.file_name)
Пример #52
0
    def test_create_request_with_right_request_params(self,
                                                      parent_breadcrumbs_from,
                                                      breadcrumb_filters,
                                                      settings):
        http_request = MagicMock()
        mock_api = MagicMock()
        mock_api.name = 'api_name'
        mock_api.version = '1.0.0.1'
        mock_user = http_request.user
        request_body = MagicMock()
        http_request.user.is_anonymous.return_value = False
        breadcrumb_filters.return_value = expected_req_params = {'bar': 'baz'}

        request = api_request_builder.build_request(http_request=http_request,
                                                    url='candidates',
                                                    api=mock_api,
                                                    request_data={},
                                                    request_body=request_body)
        assert_that(request.user, equal_to(mock_user))
        assert_that(request.request_params, equal_to(expected_req_params))
Пример #53
0
def test_prepare_environment(core):
    chute = MagicMock()
    chute.name = "test"
    chute.version = 5
    chute.get_environment.return_value = {"CHUTE_VARIABLE": "test"}

    core.info.pdid = 'halo42'

    update = MagicMock()
    update.new = chute

    service = MagicMock()
    service.environment = {"CUSTOM_VARIABLE": 42}

    env = dockerapi.prepare_environment(update, service)
    assert env['PARADROP_CHUTE_NAME'] == chute.name
    assert env['PARADROP_CHUTE_VERSION'] == chute.version
    assert env['PARADROP_ROUTER_ID'] == core.info.pdid
    assert env['CUSTOM_VARIABLE'] == 42
    assert env['CHUTE_VARIABLE'] == 'test'
Пример #54
0
    def test_add_tasks_json_without_info(self, auto_mock, find_mock):
        """Test add_tasks json without info field works."""
        auto_mock.return_value = (0, None)

        project = MagicMock()
        project.name = 'name'
        project.short_name = 'short_name'
        project.description = 'description'
        project.info = dict()

        find_mock.return_value = project

        tasks = MagicMock()
        tasks.read.return_value = json.dumps([{'key': 'value'}])

        pbclient = MagicMock()
        pbclient.create_task.return_value = {'id': 1, 'info': {'key': 'value'}}
        self.config.pbclient = pbclient
        res = _add_tasks(self.config, tasks, 'json', 0, 30)
        assert res == '1 tasks added to project: short_name', res
Пример #55
0
    def test_add_tasks_another_error(self, auto_mock, find_mock):
        """Test add_tasks another error works."""
        auto_mock.return_value = (0, None)

        project = MagicMock()
        project.name = 'name'
        project.short_name = 'short_name'
        project.description = 'description'
        project.info = dict()

        find_mock.return_value = project

        tasks = MagicMock()
        tasks.read.return_value = json.dumps([{'key': 'value'}])

        pbclient = MagicMock()
        pbclient.create_task.return_value = self.error
        self.config.pbclient = pbclient
        assert_raises(ProjectNotFound, _add_tasks, self.config, tasks, 'json',
                      0, 30)
Пример #56
0
    def make_part_tasks(self, hook, func):
        task = MagicMock()
        func_name = "configure"
        part = MagicMock()
        part.name = "test_part"
        part.method_metas = {}
        setattr(part, func_name, func)
        part_tasks = {part: task}
        hook_queue = self.c.process.create_queue.return_value

        def side_effect():
            task_return = task.define_spawn_function.call_args[0][0]
            task_return()
            return hook_queue.put.call_args[0][0]

        hook_queue.get.side_effect = side_effect

        hook.find_hooked_functions.return_value = {part: func_name}
        self.c.hook_names = {hook: "test_hook"}
        return part_tasks
Пример #57
0
    def test_add_project_event(self, mock_update_feed):
        """Test add_project_event is called."""
        conn = MagicMock()
        target = MagicMock()
        tmp = Project(id=1, name='name', short_name='short_name',
                      info=dict(container=1, thumbnail="avatar.png"))
        target.id = tmp.id
        target.project_id = tmp.id
        target.name = tmp.name
        target.short_name = tmp.short_name
        target.info = tmp.info

        conn.execute.return_value = [tmp]
        add_project_event(None, conn, target)
        assert mock_update_feed.called
        obj = tmp.to_public_json()
        obj['action_updated'] = 'Project'
        mock_update_feed.assert_called_with(obj)

        mock_update_feed.assert_called_with(obj)
Пример #58
0
    def test_edl_import_success(self):
        """
        edl_import_success should update the database record when task completes successfully
        :return:
        """
        from portal.plugins.gnmatomresponder.signals import edl_import_success
        from portal.plugins.gnmatomresponder.models import PacFormXml
        from celery import Task

        mock_sender = MagicMock(target=Task)
        mock_sender.name = "test_task"

        mock_sender.request.id = "bbba3673-1f46-4a7f-a549-81bac11955e7"

        edl_import_success(sender=mock_sender)

        pacmodel = PacFormXml.objects.get(
            celery_task_id=mock_sender.request.id)
        self.assertEqual(pacmodel.status, "PROCESSED")
        self.assertEqual(pacmodel.last_error, "")
Пример #59
0
    def test_add_tasks_json_connection_error(self, auto_mock, find_mock):
        """Test add_tasks json connection error works."""
        auto_mock.return_value = (0, None)

        project = MagicMock()
        project.name = 'name'
        project.short_name = 'short_name'
        project.description = 'description'
        project.info = dict()

        find_mock.return_value = project

        tasks = MagicMock()
        tasks.read.return_value = json.dumps([{'key': 'value'}])

        pbclient = MagicMock()
        pbclient.create_task.side_effect = exceptions.ConnectionError
        self.config.pbclient = pbclient
        res = _add_tasks(self.config, tasks, 'json', 0, 30)
        assert res == "Connection Error! The server http://server is not responding", res
Пример #60
0
Файл: GCE.py Проект: amcaar/im
    def test_10_concrete(self, get_driver):
        radl_data = """
            network net ()
            system test (
            cpu.arch='x86_64' and
            cpu.count>=1 and
            memory.size>=512m and
            net_interface.0.connection = 'net' and
            net_interface.0.dns_name = 'test' and
            disk.0.os.name = 'linux' and
            disk.0.image.url = 'gce://us-central1-a/centos-6' and
            disk.0.os.credentials.username = '******'
            )"""
        radl = radl_parse.parse_radl(radl_data)
        radl_system = radl.systems[0]

        auth = Authentication([{
            'id': 'one',
            'type': 'GCE',
            'username': '******',
            'password': '******',
            'project': 'proj'
        }])

        driver = MagicMock()
        get_driver.return_value = driver

        node_size = MagicMock()
        node_size.ram = 512
        node_size.price = 1
        node_size.disk = 1
        node_size.name = "small"
        driver.list_sizes.return_value = [node_size]

        gce_cloud = self.get_gce_cloud()
        concrete = gce_cloud.concreteSystem(radl_system, auth)
        self.assertEqual(len(concrete), 1)
        self.assertNotIn("ERROR",
                         self.log.getvalue(),
                         msg="ERROR found in log: %s" % self.log.getvalue())
        self.clean_log()