update tests to remove checks on link_type, replace with new method of setting catalog_type on root

Author: matthewhanson

tests/data-files/collections/multi-extent.json

@@ -12,11 +12,6 @@
       "href": "./area-1-1-labels/area-1-1-labels.json",
       "type": "application/json"
     },
-    {
-      "rel": "root",
-      "href": "../../catalog.json",
-      "type": "application/json"
-    },
     {
       "rel": "parent",
       "href": "../catalog.json",

tests/data-files/eo/eo-landsat-example.json

@@ -227,18 +227,5 @@
             "title": "HTML index page"
         }
     },
-    "links": [
-        {
-            "rel": "self",
-            "href": "https://odu9mlf7d6.execute-api.us-east-1.amazonaws.com/stage/search?id=LC08_L1TP_107018_20181001_20181001_01_RT"
-        },
-        {
-            "rel": "parent",
-            "href": "https://odu9mlf7d6.execute-api.us-east-1.amazonaws.com/stage/stac/collections/landsat-8-l1"
-        },
-        {
-            "rel": "root",
-            "href": "https://odu9mlf7d6.execute-api.us-east-1.amazonaws.com/stage/stac"
-        }
-    ]
+    "links": []
 }

tests/data-files/eo/sample-bands-in-item-properties.json

@@ -66,7 +66,6 @@
   "collection": "CS3",
   "links": [
     {"rel": "self", "href": "http://cool-sat.com/catalog/CS3-20160503_132130_04/CS3-20160503_132130_04.json"},
-    {"rel": "root", "href": "http://cool-sat.com/catalog/catalog.json"},
     {"rel": "parent", "href": "http://cool-sat.com/catalog/CS3-20160503_132130_04/catalog.json"},
     {"rel": "collection", "href": "http://cool-sat.com/catalog/CS3-20160503_132130_04/catalog.json"},
     {"rel": "alternate", "type": "text/html", "href": "http://cool-sat.com/catalog/CS3-20160503_132130_04/CS3-20160503_132130_04.html"}

tests/data-files/label/label-example-1.json

@@ -95,17 +95,7 @@
   "links": [
     {
       "rel": "source",
-      "href": "../area-1-1-imagery/area-1-1-imagery.json",
-      "type": "application/json"
-    },
-    {
-      "rel": "root",
-      "href": "../../../catalog.json",
-      "type": "application/json"
-    },
-    {
-      "rel": "parent",
-      "href": "../collection.json",
+      "href": "http://example.com/area-1-1-imagery/area-1-1-imagery.json",
       "type": "application/json"
     }
   ],

tests/data-files/label/label-example-2.json

@@ -88,17 +88,7 @@
   "links": [
     {
       "rel": "source",
-      "href": "../area-1-1-imagery/area-1-1-imagery.json",
-      "type": "application/json"
-    },
-    {
-      "rel": "root",
-      "href": "../../../catalog.json",
-      "type": "application/json"
-    },
-    {
-      "rel": "parent",
-      "href": "../collection.json",
+      "href": "http://example.com/area-1-1-imagery/area-1-1-imagery.json",
       "type": "application/json"
     }
   ],

tests/test_catalog.py

@@ -6,7 +6,7 @@
 from collections import defaultdict
 
 import pystac
-from pystac import (Catalog, Collection, CatalogType, Item, Asset, MediaType, Extensions)
+from pystac import (Catalog, Collection, CatalogType, Item, Asset, MediaType, Extensions, HIERARCHICAL_LINKS)
 from pystac.extensions.label import LabelClasses
 from pystac.validation import STACValidationError
 from pystac.utils import is_absolute_href
@@ -262,14 +262,6 @@ def test_clone_uses_previous_catalog_type(self):
         clone = catalog.clone()
         self.assertEqual(clone.catalog_type, CatalogType.SELF_CONTAINED)
 
-    def test_save_throws_if_no_catalog_type(self):
-        catalog = TestCases.test_case_3()
-        assert catalog.catalog_type is None
-        with TemporaryDirectory() as tmp_dir:
-            catalog.normalize_hrefs(tmp_dir)
-            with self.assertRaises(ValueError):
-                catalog.save()
-
     def test_normalize_hrefs_sets_all_hrefs(self):
         catalog = TestCases.test_case_1()
         catalog.normalize_hrefs('http://example.com')
@@ -659,23 +651,21 @@ def test_make_all_links_relative_or_absolute(self):
         def check_all_relative(cat):
             for root, catalogs, items in cat.walk():
                 for link in root.links:
-                    if link.rel != 'self':
-                        self.assertTrue(link.link_type == LinkType.RELATIVE)
+                    if link.rel in HIERARCHICAL_LINKS:
                         self.assertFalse(is_absolute_href(link.get_href()))
                 for item in items:
                     for link in item.links:
-                        if link.rel != 'self':
-                            self.assertTrue(link.link_type == LinkType.RELATIVE)
+                        if link.rel in HIERARCHICAL_LINKS:
+                            if is_absolute_href(link.get_href()):
+                                import pdb; pdb.set_trace()
                             self.assertFalse(is_absolute_href(link.get_href()))
 
         def check_all_absolute(cat):
             for root, catalogs, items in cat.walk():
                 for link in root.links:
-                    self.assertTrue(link.link_type == LinkType.ABSOLUTE)
                     self.assertTrue(is_absolute_href(link.get_href()))
                 for item in items:
                     for link in item.links:
-                        self.assertTrue(link.link_type == LinkType.ABSOLUTE)
                         self.assertTrue(is_absolute_href(link.get_href()))
 
         test_cases = TestCases.all_test_catalogs()
@@ -684,9 +674,9 @@ def check_all_absolute(cat):
             with TemporaryDirectory() as tmp_dir:
                 c2 = catalog.full_copy()
                 c2.normalize_hrefs(tmp_dir)
-                c2.make_all_links_relative()
+                c2.catalog_type = CatalogType.RELATIVE_PUBLISHED
                 check_all_relative(c2)
-                c2.make_all_links_absolute()
+                c2.catalog_type = CatalogType.ABSOLUTE_PUBLISHED
                 check_all_absolute(c2)
 
     def test_full_copy_and_normalize_works_with_created_stac(self):

tests/test_link.py

@@ -49,18 +49,6 @@ def test_minimal(self):
         link.set_owner(None)
         self.assertIsNone(link.owner)
 
-        self.assertEqual(pystac.LinkType.ABSOLUTE, link.link_type)
-
-        link.make_absolute()
-        self.assertEqual(pystac.LinkType.ABSOLUTE, link.link_type)
-        self.assertEqual(target, link.get_href())
-        self.assertEqual(target, link.get_absolute_href())
-
-        link.make_relative()
-        self.assertEqual(pystac.LinkType.RELATIVE, link.link_type)
-        self.assertEqual(target, link.get_href())
-        self.assertEqual(target, link.get_absolute_href())
-
         link.set_owner(self.item)
         self.assertEqual(self.item, link.owner)
 
@@ -72,8 +60,7 @@ def test_relative(self):
                            target,
                            mime_type,
                            'a title',
-                           properties={'a': 'b'},
-                           link_type=pystac.LinkType.RELATIVE)
+                           properties={'a': 'b'})
         expected_dict = {
             'rel': rel,
             'href': target,
@@ -83,14 +70,11 @@ def test_relative(self):
         }
         self.assertEqual(expected_dict, link.to_dict())
 
-        self.assertEqual(pystac.LinkType.RELATIVE, link.link_type)
-
     def test_link_does_not_fail_if_href_is_none(self):
         """Test to ensure get_href does not fail when the href is None."""
         catalog = pystac.Catalog(id='test', description='test desc')
         catalog.add_item(self.item)
         catalog.set_self_href('/some/href')
-        catalog.make_all_links_relative()
 
         link = catalog.get_single_link('item')
         self.assertIsNone(link.get_href())
@@ -133,52 +117,11 @@ def test_from_dict_round_trip(self):
             d2 = pystac.Link.from_dict(d).to_dict()
             self.assertEqual(d, d2)
 
-    def test_from_dict_link_type(self):
-        test_cases = [
-            ({
-                'rel': '',
-                'href': 'https://a'
-            }, pystac.LinkType.ABSOLUTE),
-            ({
-                'rel': '',
-                'href': '/a'
-            }, pystac.LinkType.ABSOLUTE),
-            ({
-                'rel': '',
-                'href': 'a'
-            }, pystac.LinkType.RELATIVE),
-            ({
-                'rel': '',
-                'href': './a'
-            }, pystac.LinkType.RELATIVE),
-            # 'self' is a special case.
-            ({
-                'rel': 'self',
-                'href': 'does not matter'
-            }, pystac.LinkType.ABSOLUTE),
-        ]
-        for case in test_cases:
-            item = pystac.Link.from_dict(case[0])
-            self.assertEqual(case[1], item.link_type)
-
     def test_from_dict_failures(self):
         for d in [{}, {'href': 't'}, {'rel': 'r'}]:
             with self.assertRaises(KeyError):
                 pystac.Link.from_dict(d)
 
-        for d in [
-            {
-                'rel': '',
-                'href': 1
-            },
-            {
-                'rel': '',
-                'href': None
-            },
-        ]:
-            with self.assertRaises(AttributeError):
-                pystac.Link.from_dict(d)
-
     def test_collection(self):
         c = pystac.Collection('collection id', 'desc', extent=None)
         link = pystac.Link.collection(c)

tests/test_writing.py

@@ -1,7 +1,7 @@
 import unittest
 from tempfile import TemporaryDirectory
 
-from pystac import (STAC_IO, STACObject, Collection, CatalogType)
+from pystac import (STAC_IO, STACObject, Collection, CatalogType, HIERARCHICAL_LINKS)
 from pystac.serialization import (STACObjectType)
 from pystac.utils import is_absolute_href, make_absolute_href, make_relative_href
 from pystac.validation import validate_dict
@@ -30,12 +30,11 @@ def validate_file(self, path, object_type):
         d = STAC_IO.read_json(path)
         return validate_dict(d, object_type)
 
-    def validate_link_types(self, root_href, catalog_type):
+    def validate_link_types(self, root_href, catalog_type):           
+
         def validate_asset_href_type(item, item_href, link_type):
             for asset in item.assets.values():
-                if link_type == LinkType.ABSOLUTE:
-                    self.assertTrue(is_absolute_href(asset.href))
-                else:
+                if not is_absolute_href(asset.href):
                     is_valid = not is_absolute_href(asset.href)
                     if not is_valid:
                         # If the item href and asset href don't share
@@ -50,7 +49,10 @@ def validate_item_link_type(href, link_type, should_include_self):
             item = STACObject.from_file(href)
             for link in item.get_links():
                 if not link.rel == 'self':
-                    self.assertEqual(link.link_type, link_type)
+                    if link_type == 'RELATIVE' and link.rel in HIERARCHICAL_LINKS:
+                        self.assertFalse(is_absolute_href(link.get_href()))
+                    else:
+                        self.assertTrue(is_absolute_href(link.get_href()))
 
             validate_asset_href_type(item, href, link_type)
 
@@ -60,9 +62,6 @@ def validate_item_link_type(href, link_type, should_include_self):
         def validate_catalog_link_type(href, link_type, should_include_self):
             cat_dict = STAC_IO.read_json(href)
             cat = STACObject.from_file(href)
-            for link in cat.get_links():
-                if not link.rel == 'self':
-                    self.assertEqual(link.link_type, link_type)
 
             rels = set([link['rel'] for link in cat_dict['links']])
             self.assertEqual('self' in rels, should_include_self)
@@ -77,9 +76,9 @@ def validate_catalog_link_type(href, link_type, should_include_self):
                 validate_item_link_type(item_href, link_type,
                                         catalog_type == CatalogType.ABSOLUTE_PUBLISHED)
 
-        link_type = LinkType.RELATIVE
+        link_type = 'RELATIVE'
         if catalog_type == CatalogType.ABSOLUTE_PUBLISHED:
-            link_type = LinkType.ABSOLUTE
+            link_type = 'ABSOLUTE'
 
         root_should_include_href = catalog_type in [
             CatalogType.ABSOLUTE_PUBLISHED, CatalogType.RELATIVE_PUBLISHED
@@ -110,9 +109,11 @@ def do_test(self, catalog, catalog_type):
     def test_testcases(self):
         for catalog in TestCases.all_test_catalogs():
             catalog = catalog.full_copy()
-            for catalog_type in [
-                    CatalogType.ABSOLUTE_PUBLISHED, CatalogType.RELATIVE_PUBLISHED,
-                    CatalogType.SELF_CONTAINED
-            ]:
+            ctypes = [
+                      CatalogType.ABSOLUTE_PUBLISHED,
+                      CatalogType.RELATIVE_PUBLISHED,
+                      CatalogType.SELF_CONTAINED
+                    ]
+            for catalog_type in ctypes:
                 with self.subTest(title='Catalog {} [{}]'.format(catalog.id, catalog_type)):
                     self.do_test(catalog, catalog_type)