Beispiel #1
0
    def test_identity_from_dict(self):

        name = Name(source='source.com',
                    dataset='foobar',
                    variation='orig',
                    version='0.0.1')
        dataset_number = DatasetNumber(10000, 1, assignment_class='registered')

        oident = Identity(name, dataset_number)
        opident = oident.as_partition(7)

        idict = oident.dict
        pidict = opident.dict

        ident = Identity.from_dict(idict)

        self.assertIsInstance(ident, Identity)
        self.assertEqual(ident.fqname, oident.fqname)

        ident = Identity.from_dict(pidict)

        self.assertEqual('source.com/foobar-orig-0.0.1', ident.cache_key)
Beispiel #2
0
    def test_split(self):

        name = Name(source='source.com', dataset='foobar', version='1.2.3')
        dn = DatasetNumber(10000, 1, assignment_class='registered')

        # NOTE, version is entered as 1.2.3, but will be changed to 1.2.1 b/c
        # last digit is overridden by revision

        ident = Identity(name, dn)

        ip = Identity.classify(name)
        self.assertEqual(Name, ip.isa)
        self.assertIsNone(ip.version)

        ip = Identity.classify(ident.name)

        self.assertEqual(Name, ip.isa)
        self.assertIsNone(ip.on)
        self.assertEqual(ident.sname, ip.name)
        self.assertIsNone(ip.version)

        ip = Identity.classify(ident.vname)
        self.assertEqual(Name, ip.isa)
        self.assertIsNone(ip.on)
        self.assertEqual(ident.vname, ip.name)
        self.assertEqual(ident._name.version, str(ip.version))

        ip = Identity.classify(ident.fqname)
        self.assertEqual(DatasetNumber, ip.isa)
        self.assertEqual(ident.vname, ip.name)
        self.assertEqual(str(ip.on), str(ip.on))

        ip = Identity.classify(ident.vid)
        self.assertEqual(DatasetNumber, ip.isa)

        ip = Identity.classify(ident.id_)
        self.assertEqual(DatasetNumber, ip.isa)

        ip = Identity.classify(dn)
        self.assertEqual(DatasetNumber, ip.isa)

        ip = Identity.classify(dn.as_partition(10))
        self.assertEqual(PartitionNumber, ip.isa)

        ip = Identity.classify('source.com-foobar-orig')
        self.assertIsNone(ip.version)
        self.assertEqual('source.com-foobar-orig', ip.sname)
        self.assertIsNone(ip.vname)

        ip = Identity.classify('source.com-foobar-orig-1.2.3')
        self.assertIsInstance(ip.version, Version)
        self.assertEqual('source.com-foobar-orig', ip.sname)
        self.assertEqual('source.com-foobar-orig-1.2.3', ip.vname)

        ip = Identity.classify('source.com-foobar-orig->=1.2.3')
        self.assertIsInstance(ip.version, Spec)
        self.assertEqual('source.com-foobar-orig', ip.sname)
        self.assertIsNone(ip.vname)

        ip = Identity.classify('source.com-foobar-orig-==1.2.3')
        self.assertIsInstance(ip.version, Spec)
        self.assertEqual('source.com-foobar-orig', ip.sname)
        self.assertIsNone(ip.vname)
Beispiel #3
0
    def test_identity(self):

        name = Name(source='source.com',
                    dataset='foobar',
                    version='0.0.1',
                    variation='orig')
        dn = DatasetNumber(10000, 1, assignment_class='registered')

        ident = Identity(name, dn)

        self.assertEqual('d002Bi', ident.id_)
        self.assertEqual('d002Bi001', ident.vid)
        self.assertEqual('source.com-foobar-orig', str(ident.name))
        self.assertEqual('source.com-foobar-orig-0.0.1', ident.vname)
        self.assertEqual('source.com-foobar-orig-0.0.1~d002Bi001',
                         ident.fqname)
        self.assertEqual('source.com/foobar-orig-0.0.1', ident.path)
        self.assertEqual('source.com/foobar-orig', ident.source_path)
        self.assertEqual('source.com/foobar-orig-0.0.1', ident.cache_key)

        self.assertEqual('source.com-foobar-orig-0.0.1',
                         ident.name.dict['vname'])

        self.assertEqual(
            {
                'id', 'vid', 'revision', 'name', 'vname', 'cache_key',
                'variation', 'dataset', 'source', 'version'
            }, set(ident.dict.keys()))

        self.assertIn('fqname', ident.names_dict)
        self.assertIn('vname', ident.names_dict)
        self.assertNotIn('dataset', ident.names_dict)

        self.assertIn('dataset', ident.ident_dict)
        self.assertNotIn('fqname', ident.ident_dict)

        # Clone to get a PartitionIdentity

        pi = ident.as_partition(7)
        self.assertEqual('source.com-foobar-orig-0.0.1~p002Bi007001',
                         pi.fqname)

        pi = ident.as_partition(8, time='time', space='space', format='geo')

        self.assertEqual(
            'source.com-foobar-orig-time-space-geo-0.0.1~p002Bi008001',
            pi.fqname)

        # PartitionIdentity

        part_name = PartitionName(time='time',
                                  space='space',
                                  format='geo',
                                  **name.dict)

        pn = PartitionNumber(dn, 500)

        ident = PartitionIdentity(part_name, pn)

        expected_keys = set([
            'id', 'vid', 'revision', 'cache_key', 'name', 'vname', 'space',
            'format', 'variation', 'dataset', 'source', 'version', 'time'
        ])
        self.assertEqual(expected_keys, set(ident.dict.keys()))

        self.assertEqual('p002Bi084', ident.id_)
        self.assertEqual('p002Bi084001', ident.vid)
        self.assertEqual('source.com-foobar-orig-time-space-geo',
                         str(ident.name))
        self.assertEqual('source.com-foobar-orig-time-space-geo-0.0.1',
                         ident.vname)
        self.assertEqual(
            'source.com-foobar-orig-time-space-geo-0.0.1~p002Bi084001',
            ident.fqname)
        self.assertEqual('source.com/foobar-orig-0.0.1/geo/time-space',
                         ident.path)
        self.assertEqual('source.com/foobar-orig-0.0.1/geo/time-space',
                         ident.cache_key)

        # Updating partition names that were partially specified

        PartitionNameQuery(time='time', space='space', format='hdf')
        # pnq = PartitionNameQuery(time='time', space='space', format='hdf')

        # Partitions, converting to datasets

        ident = Identity(name, dn)
        pi = ident.as_partition(8, time='time', space='space', format='geo')

        self.assertEqual(
            'source.com-foobar-orig-time-space-geo-0.0.1~p002Bi008001',
            pi.fqname)

        iid = pi.as_dataset()

        self.assertEqual(ident.fqname, iid.fqname)