Did I find the right examples for you? yes no

All Samples(100)  |  Call(100)  |  Derive(0)  |  Import(0)
Assert that 'observed' is not equal to None.

:param observed: The observed value.
:param message: An optional message describing the error.

src/t/r/trove-HEAD/trove/tests/unittests/api/test_versions.py   trove(Download)
    def setUp(self):
        super(VersionsControllerTest, self).setUp()
        self.controller = VersionsController()
        self.assertIsNotNone(self.controller,
                             "VersionsController instance was None")
 
    def test_index_json(self):
        request = Mock()
        result = self.controller.index(request)
        self.assertIsNotNone(result,
        json_data = result.data("application/json")
 
        self.assertIsNotNone(json_data,
                             'Result json_data was None')
        self.assertEqual('v1.0', json_data['id'],
    def test_show_json(self):
        request = Mock()
        request.url_version = '1.0'
        result = self.controller.show(request)
        self.assertIsNotNone(result,
                             'Result was None')
        json_data = result.data("application/json")
        self.assertIsNotNone(json_data, "JSON data was None")

src/t/r/trove-HEAD/trove/tests/unittests/backup/test_storage.py   trove(Download)
 
        self.assertTrue(success, "The backup should have been successful.")
        self.assertIsNotNone(note, "A note should have been returned.")
        self.assertEqual('http://mockswift/v1/database_backups/123.gz.enc',
                         location,
            storage_strategy = SwiftStorage(context)
            download_stream = storage_strategy.load(location, backup_checksum)
        self.assertIsNotNone(download_stream)
 
    def test_run_verify_checksum_mismatch(self):

src/t/e/testtools-0.9.35/testtools/tests/test_testcase.py   testtools(Download)
    def test_assertIsNotNone(self):
        self.assertIsNotNone(0)
        self.assertIsNotNone("0")
 
        expected_error = 'None matches Is(None)'

src/t/e/testtools-HEAD/testtools/tests/test_testcase.py   testtools(Download)
    def test_assertIsNotNone(self):
        self.assertIsNotNone(0)
        self.assertIsNotNone("0")
 
        expected_error = 'None matches Is(None)'

src/t/r/trove-HEAD/trove/tests/unittests/instance/test_instance_controller.py   trove(Download)
    def test_get_schema_create(self):
        schema = self.controller.get_schema('create', {'instance': {}})
        self.assertIsNotNone(schema)
        self.assertTrue('instance' in schema['properties'])
 
    def test_get_schema_action_restart(self):
        schema = self.controller.get_schema('action', {'restart': {}})
        self.assertIsNotNone(schema)
    def test_get_schema_action_resize_volume(self):
        schema = self.controller.get_schema(
            'action', {'resize': {'volume': {}}})
        self.assertIsNotNone(schema)
        self.assertTrue('resize' in schema['properties'])
    def test_get_schema_action_resize_flavorRef(self):
        schema = self.controller.get_schema(
            'action', {'resize': {'flavorRef': {}}})
        self.assertIsNotNone(schema)
        self.assertTrue('resize' in schema['properties'])
    def test_get_schema_action_other(self):
        schema = self.controller.get_schema(
            'action', {'supersized': {'flavorRef': {}}})
        self.assertIsNotNone(schema)
        self.assertThat(len(schema.keys()), Is(0))

src/z/u/zuul-HEAD/tests/test_scheduler.py   zuul(Download)
 
        # There are... four... refs.
        self.assertIsNotNone(a_zref)
        self.assertIsNotNone(b_zref)
        self.assertIsNotNone(c_zref)
        self.assertIsNotNone(d_zref)

src/b/a/barbican-HEAD/barbican/tests/tasks/test_resources.py   barbican(Download)
        datum = args[0]
        self.assertIsInstance(datum, models.EncryptedDatum)
        self.assertIsNotNone(datum.cypher_text)
 
        self.assertIsNone(datum.kek_meta_extended)
        self.assertIsNotNone(datum.kek_meta_tenant)
        self.assertTrue(datum.kek_meta_tenant.bind_completed)
        self.assertIsNotNone(datum.kek_meta_tenant.plugin_name)
        self.assertIsNotNone(datum.kek_meta_tenant.kek_label)

src/z/u/zuul-2.0.0/tests/test_scheduler.py   zuul(Download)
 
        # There are... four... refs.
        self.assertIsNotNone(a_zref)
        self.assertIsNotNone(b_zref)
        self.assertIsNotNone(c_zref)
        self.assertIsNotNone(d_zref)

src/t/r/trove-HEAD/trove/tests/unittests/backup/test_backupagent.py   trove(Download)
        mysql_dump = mysql_impl.MySQLDump(
            'abc', extra_opts='')
        self.assertIsNotNone(mysql_dump.cmd)
        str_mysql_dump_cmd = ('mysqldump'
                              ' --all-databases'
                              '-pass pass:default_aes_cbc_key')
        self.assertEqual(mysql_dump.cmd, str_mysql_dump_cmd)
        self.assertIsNotNone(mysql_dump.manifest)
        self.assertEqual(mysql_dump.manifest, 'abc.gz.enc')
 
        """
        inno_backup_ex = mysql_impl.InnoBackupEx('innobackupex', extra_opts='')
        self.assertIsNotNone(inno_backup_ex.cmd)
        str_innobackup_cmd = ('sudo innobackupex'
                              ' --stream=xbstream'
                              '-pass pass:default_aes_cbc_key')
        self.assertEqual(inno_backup_ex.cmd, str_innobackup_cmd)
        self.assertIsNotNone(inno_backup_ex.manifest)
        str_innobackup_manifest = 'innobackupex.xbstream.gz.enc'
        self.assertEqual(inno_backup_ex.manifest, str_innobackup_manifest)
        if backup_runner.is_zipped:
            self.assertEqual(backup_runner.zip_manifest, '.gz')
            self.assertIsNotNone(backup_runner.zip_manifest)
            self.assertIsNotNone(backup_runner.zip_cmd)
            self.assertEqual(backup_runner.zip_cmd, ' | gzip')

src/t/r/trove-HEAD/trove/tests/unittests/taskmanager/test_models.py   trove(Download)
            None, None, None, None, None, availability_zone='nova', nics=None)
        # verify
        self.assertIsNotNone(server)
 
    @patch('trove.taskmanager.models.CONF')
            None, None, None, None, None, 'nova', None)
        # verify
        self.assertIsNotNone(server)
 
    @patch('trove.taskmanager.models.CONF')
            None, None, None, None, None, None, None)
        # verify
        self.assertIsNotNone(server)
 
    @patch('trove.taskmanager.models.CONF')
    def test_report_root_first_time(self):
        report = mysql_models.RootHistory.create(
            None, utils.generate_uuid(), 'root')
        self.assertIsNotNone(report)
 

  1 | 2 | 3  Next