Use luci-config for infrequently changing settings, part 2.

appengine/auth_service/importer_test.py

 #!/usr/bin/env python
 # Copyright 2014 The Swarming Authors. All rights reserved.
 # Use of this source code is governed by the Apache v2.0 license that can be
 # found in the LICENSE file.
 
 import collections
 import datetime
 import logging
 import os
 import StringIO
 import sys
 import tarfile
 import tempfile
+import textwrap
 import unittest
 
 APP_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
 import test_env
 test_env.setup_test_env()
 
 from google.appengine.ext import ndb
 
 from components import auth
 from components import auth_testing
 from components.auth import model
 from test_support import test_case
 
+# Must be after 'components' import, since they add it to sys.path.
+from google import protobuf
+
+from proto import config_pb2
 import importer
 
 
 def build_tar_gz(content):
   """Returns bytes of tar.gz archive build from {filename -> body} dict."""
   out = StringIO.StringIO()
   with tarfile.open(mode='w|gz', fileobj=out) as tar:
     for name, value in content.iteritems():
       # tarfile module doesn't support in-memory files (it tries to os.stat
       # them), so dump to disk first to keep the code simple.
@@ skipping 24 matching lines @@
       modified_by=ident('admin'),
       modified_ts=datetime.datetime(1999, 1, 2, 3, 4, 5, 6),
       members=[ident(x) for x in members],
       nested=nested or [])
 
 
 def fetch_groups():
   return {x.key.id(): x.to_dict() for x in model.AuthGroup.query()}
 
 
+def put_config(config_proto, config):
+  importer.GroupImporterConfig(
+      key=importer.config_key(),
+      config_proto=config_proto,
+      config=config).put()
+
+
 class ImporterTest(test_case.TestCase):
   def setUp(self):
     super(ImporterTest, self).setUp()
     auth_testing.mock_is_admin(self, True)
     auth_testing.mock_get_current_identity(self)
 
   def mock_urlfetch(self, urls):
     def mock_get_access_token(*_args):
       return 'token', 0
     self.mock(auth, 'get_access_token', mock_get_access_token)
@@ skipping 134 matching lines @@
         systems=['ldap'],
         groups=['ldap/group-a', 'ldap/group-b'],
         domain='example.com')
 
   def test_import_external_groups(self):
     self.mock_now(datetime.datetime(2010, 1, 2, 3, 4, 5, 6))
 
     service_id = auth.Identity.from_bytes('service:some-service')
     self.mock(auth, 'get_service_self_identity', lambda: service_id)
 
-    importer.write_config([
-      {
-        'domain': 'example.com',
-        'format': 'tarball',
-        'groups': ['ldap/new'],
-        'oauth_scopes': ['scope'],
-        'systems': ['ldap'],
-        'url': 'https://fake_tarball',
-      },
-      {
-        'format': 'plainlist',
-        'group': 'external_1',
-        'oauth_scopes': ['scope'],
-        'url': 'https://fake_external_1',
-      },
-      {
-        'description': 'Some external group',
-        'domain': 'example.com',
-        'format': 'plainlist',
-        'group': 'external_2',
-        'oauth_scopes': ['scope'],
-        'url': 'https://fake_external_2',
-      },
-    ])
+    importer.write_config_text("""
+      tarball {
+        domain: "example.com"
+        groups: "ldap/new"
+        oauth_scopes: "scope"
+        systems: "ldap"
+        url: "https://fake_tarball"
+      }
+      plainlist {
+        group: "external_1"
+        oauth_scopes: "scope"
+        url: "https://fake_external_1"
+      }
+      plainlist {
+        domain: "example.com"
+        group: "external_2"
+        oauth_scopes: "scope"
+        url: "https://fake_external_2"
+      }
+    """)
 
     self.mock_urlfetch({
       'https://fake_tarball': build_tar_gz({
         'ldap/new': 'a\nb',
       }),
       'https://fake_external_1': 'abc@test.com\ndef@test.com\n',
       'https://fake_external_2': '123\n456',
     })
 
     # Should be deleted during import, since not in a imported bundle.
@@ skipping 36 matching lines @@
         'description': u'',
         'globs': [],
         'members': [ident('123'), ident('456')],
         'modified_by': service_id,
         'modified_ts': datetime.datetime(2010, 1, 2, 3, 4, 5, 6),
         'nested': [],
       },
     }
     self.assertEqual(expected_groups, fetch_groups())
 
+  def test_read_config_text(self):
+    # Empty.
+    put_config('', '')
+    self.assertEqual('', importer.read_config_text())
+    # Good.
+    put_config('tarball{}', '')
+    self.assertEqual('tarball{}', importer.read_config_text())
+    # Legacy.
+    put_config('', '[{"url":"12"}]')
+    self.assertEqual('tarball {\n  url: "12"\n}\n', importer.read_config_text())
+
+  def test_write_config_text(self):
+    put_config('', 'legacy')
+    importer.write_config_text('tarball{url:"12"\nsystems:"12"}')
+    e = importer.config_key().get()
+    self.assertEqual('legacy', e.config)
+    self.assertEqual('tarball{url:"12"\nsystems:"12"}', e.config_proto)
+
+  def test_legacy_json_config_to_proto(self):
+    msg = importer.legacy_json_config_to_proto("""
+    [
+      {
+        "url": "https://example.com/all_users",
+        "group": "plain-list",
+        "format": "plainlist"
+      },
+      {
+        "url": "https://example.com/tarball.tar.gz",
+        "domain": "example.com",
+        "oauth_scopes": [
+          "oauth-scope"
+        ],
+        "systems": [
+          "ldap"
+        ],
+        "groups": [
+          "ldap/a",
+          "ldap/b"
+        ]
+      }
+    ]
+    """)
+    expected = textwrap.dedent("""
+    tarball {
+      url: "https://example.com/tarball.tar.gz"
+      oauth_scopes: "oauth-scope"
+      domain: "example.com"
+      systems: "ldap"
+      groups: "ldap/a"
+      groups: "ldap/b"
+    }
+    plainlist {
+      url: "https://example.com/all_users"
+      group: "plain-list"
+    }
+    """.lstrip('\n'))
+    self.assertEqual(expected, protobuf.text_format.MessageToString(msg))
+
 
 if __name__ == '__main__':
   if '-v' in sys.argv:
     unittest.TestCase.maxDiff = None
     logging.basicConfig(level=logging.DEBUG)
   else:
     logging.basicConfig(level=logging.FATAL)
   unittest.main()