rigid 0.2.0

data/vendor/tests/integration/test_deploy.py

@@ -0,0 +1,128 @@
+import os
+import unittest
+from click.testing import CliRunner
+
+from rigid.commands import cli
+
+from ..utils import FakeServer
+
+FIXTURES = os.path.join(os.path.dirname(__file__), '..', 'fixtures')
+
+class DeployTests(unittest.TestCase):
+    def setUp(self):
+        super(DeployTests, self).setUp()
+        self.server = FakeServer()
+
+        self.server.status = 200
+        self.server.responses = [
+            # Preflight (head)
+            {},
+
+            # Create Source
+            {'body': {'uuid': 'source-uuid', 'upload': {'method': 'PUT', 'url': self.server.url + '/upload-source'}}},
+
+            # Upload Source
+            {},
+
+            # Create version
+            {'body': {'uuid': 'version-uuid'}},
+
+            # Promote version
+            {'body': {}},
+        ]
+
+    def test_deploy_without_app(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ['deploy', FIXTURES], env={'RIGID_API': self.server.url})
+        self.assertEqual(result.exit_code, 2)
+        self.assertEqual(result.output, 'Usage: cli deploy [OPTIONS] SOURCE\n\nError: Missing option "--app" / "-a".\n')
+
+
+    def test_deploy_success(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ['deploy', '-a', 'testingapp', FIXTURES], env={'RIGID_API': self.server.url}, catch_exceptions=False)
+        self.assertEqual(result.exit_code, 0)
+
+        self.assertEqual(len(self.server.requests),  5)
+
+        # Preflight (to check auth and permissions to app)
+        self.assertEqual(self.server.requests[0]['method'],  'HEAD')
+        self.assertEqual(self.server.requests[0]['path'],  '/apps/testingapp')
+
+        # Create a source
+        self.assertEqual(self.server.requests[1]['method'],  'POST')
+        self.assertEqual(self.server.requests[1]['path'],  '/sources')
+
+        # Upload source
+        self.assertEqual(self.server.requests[2]['method'],  'PUT')
+        self.assertEqual(self.server.requests[2]['path'],  '/upload-source')
+
+        # Create version
+        self.assertEqual(self.server.requests[3]['method'],  'POST')
+        self.assertEqual(self.server.requests[3]['path'],  '/apps/testingapp/versions')
+
+        # Promote version
+        self.assertEqual(self.server.requests[4]['method'],  'PUT')
+        self.assertEqual(self.server.requests[4]['path'],  '/apps/testingapp/aliases/production')
+
+    def test_deploy_create(self):
+        self.server.responses = [
+            {'body': {'name': 'testingapp'}}
+        ] + self.server.responses[1:]
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['deploy', '--create', '-a', 'testingapp', FIXTURES], env={'RIGID_API': self.server.url}, catch_exceptions=False)
+        self.assertEqual(result.exit_code, 0)
+
+        self.assertEqual(len(self.server.requests),  5)
+
+        # Preflight (to check auth and permissions to app)
+        self.assertEqual(self.server.requests[0]['method'],  'POST')
+        self.assertEqual(self.server.requests[0]['path'],  '/apps')
+
+        # Create a source
+        self.assertEqual(self.server.requests[1]['method'],  'POST')
+        self.assertEqual(self.server.requests[1]['path'],  '/sources')
+
+        # Upload source
+        self.assertEqual(self.server.requests[2]['method'],  'PUT')
+        self.assertEqual(self.server.requests[2]['path'],  '/upload-source')
+
+        # Create version
+        self.assertEqual(self.server.requests[3]['method'],  'POST')
+        self.assertEqual(self.server.requests[3]['path'],  '/apps/testingapp/versions')
+
+        # Promote version
+        self.assertEqual(self.server.requests[4]['method'],  'PUT')
+        self.assertEqual(self.server.requests[4]['path'],  '/apps/testingapp/aliases/production')
+
+    def test_deploy_create_random_name(self):
+        self.server.responses = [
+            {'body': {'name': 'rando'}}
+        ] + self.server.responses[1:]
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['deploy', '--create', FIXTURES], env={'RIGID_API': self.server.url})
+        self.assertEqual(result.exit_code, 0)
+
+        self.assertEqual(len(self.server.requests),  5)
+
+        # Preflight (to check auth and permissions to app)
+        self.assertEqual(self.server.requests[0]['method'],  'POST')
+        self.assertEqual(self.server.requests[0]['path'],  '/apps')
+
+        # Create a source
+        self.assertEqual(self.server.requests[1]['method'],  'POST')
+        self.assertEqual(self.server.requests[1]['path'],  '/sources')
+
+        # Upload source
+        self.assertEqual(self.server.requests[2]['method'],  'PUT')
+        self.assertEqual(self.server.requests[2]['path'],  '/upload-source')
+
+        # Create version
+        self.assertEqual(self.server.requests[3]['method'],  'POST')
+        self.assertEqual(self.server.requests[3]['path'],  '/apps/rando/versions')
+
+        # Promote version
+        self.assertEqual(self.server.requests[4]['method'],  'PUT')
+        self.assertEqual(self.server.requests[4]['path'],  '/apps/rando/aliases/production')

data/vendor/tests/integration/test_domains.py

@@ -0,0 +1,35 @@
+import unittest
+from click.testing import CliRunner
+
+from rigid.commands import cli
+
+from ..utils import FakeServer
+
+
+class DomainTests(unittest.TestCase):
+    def setUp(self):
+        super(DomainTests, self).setUp()
+        self.server = FakeServer()
+
+    def test_add_domain(self):
+        self.server.status = 202
+        self.server.body = {}
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['domains', '--add', 'example.com', '-a', 'test'], env={'RIGID_API': self.server.url}, catch_exceptions=False)
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, 'example.com has been added to test.\n')
+
+        self.assertEqual(self.server.request['method'], 'POST')
+        self.assertEqual(self.server.request['path'], '/apps/test/aliases/production/domains')
+
+    def test_remove_domain(self):
+        self.server.status = 204
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['domains', '--remove', 'example.com', '-a', 'test'], env={'RIGID_API': self.server.url})
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, 'example.com has been removed from test.\n')
+
+        self.assertEqual(self.server.request['method'], 'DELETE')
+        self.assertEqual(self.server.request['path'], '/apps/test/aliases/production/domains/example.com')

data/vendor/tests/integration/test_login.py

@@ -0,0 +1,37 @@
+import unittest
+from click.testing import CliRunner
+
+from rigid.commands import cli
+
+from ..utils import FakeServer
+
+
+class LoginTests(unittest.TestCase):
+    def setUp(self):
+        super(LoginTests, self).setUp()
+        self.server = FakeServer()
+
+    def test_login_success(self):
+        self.server.status = 200
+        self.server.body = { 'token': 'abc' }
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['login'], input='kyle@example.com\nsecretpw\n', env={'RIGID_API': self.server.url})
+        self.assertEqual(result.exit_code, 0)
+
+        self.assertEqual(self.server.request['method'], 'POST')
+        self.assertEqual(self.server.request['path'], '/authorizations')
+        self.assertEqual(self.server.request['headers']['Authorization'], 'Basic a3lsZUBleGFtcGxlLmNvbTpzZWNyZXRwdw==')
+
+    def test_login_failure(self):
+        self.server.status = 401
+        self.server.body = {}
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['login'], input='kyle@example.com\nsecret\n', env={'RIGID_API': self.server.url})
+        self.assertEqual(result.exit_code, 1)
+        self.assertEqual(result.output, 'Enter your Rigid credentials.\nEmail: kyle@example.com\nPassword: \nError: Invalid Credentials\n')
+
+        self.assertEqual(self.server.request['method'], 'POST')
+        self.assertEqual(self.server.request['path'], '/authorizations')
+        self.assertEqual(self.server.request['headers']['Authorization'], 'Basic a3lsZUBleGFtcGxlLmNvbTpzZWNyZXQ=')

data/vendor/tests/integration/test_promote.py

@@ -0,0 +1,24 @@
+import unittest
+from click.testing import CliRunner
+
+from rigid.commands import cli
+
+from ..utils import FakeServer
+
+
+class PromoteTests(unittest.TestCase):
+    def setUp(self):
+        super(PromoteTests, self).setUp()
+        self.server = FakeServer()
+
+    def test_promote(self):
+        self.server.status = 200
+        self.server.body = {'version': 'testing'}
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['promote', '-a', 'test', 'abc'], env={'RIGID_API': self.server.url}, catch_exceptions=False)
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, 'test/production is now running testing.\n')
+
+        self.assertEqual(self.server.request['method'], 'PUT')
+        self.assertEqual(self.server.request['path'], '/apps/test/aliases/production')

data/vendor/tests/integration/test_token.py

@@ -0,0 +1,33 @@
+import unittest
+from click.testing import CliRunner
+
+from rigid.commands import cli
+
+from ..utils import FakeServer
+
+
+class TokenTests(unittest.TestCase):
+    def setUp(self):
+        super(TokenTests, self).setUp()
+        self.server = FakeServer()
+
+        self.server.status = 200
+        self.server.body = { 'token': 'abc' }
+
+    def test_token_success(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ['token'], env={'RIGID_API': self.server.url})
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, 'abc\n')
+
+        self.assertEqual(self.server.request['method'], 'POST')
+        self.assertEqual(self.server.request['path'], '/authorizations')
+
+    def test_token_with_scopes(self):
+        runner = CliRunner()
+        result = runner.invoke(cli, ['token', '--scope', 'example'], env={'RIGID_API': self.server.url})
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, 'abc\n')
+
+        self.assertEqual(self.server.request['method'], 'POST')
+        self.assertEqual(self.server.request['path'], '/authorizations')

data/vendor/tests/integration/test_whoami.py

@@ -0,0 +1,24 @@
+import unittest
+from click.testing import CliRunner
+
+from rigid.commands import cli
+
+from ..utils import FakeServer
+
+
+class WhoamiTests(unittest.TestCase):
+    def setUp(self):
+        super(WhoamiTests, self).setUp()
+        self.server = FakeServer()
+
+    def test_whoami_success(self):
+        self.server.status = 200
+        self.server.body = { 'email': 'kyle@example.com' }
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['whoami'], env={'RIGID_API': self.server.url})
+        self.assertEqual(result.exit_code, 0)
+        self.assertEqual(result.output, 'kyle@example.com\n')
+
+        self.assertEqual(self.server.request['method'], 'GET')
+        self.assertEqual(self.server.request['path'], '/user')

data/vendor/tests/test_deploy.py

@@ -0,0 +1,33 @@
+import os
+import unittest
+from threading import Thread
+
+from six.moves import BaseHTTPServer
+
+from rigid.api import Client
+from rigid.deploy import Deploy
+
+from .utils import FakeServer
+
+FIXTURES = os.path.join(os.path.dirname(__file__), 'fixtures')
+
+
+class DeployTests(unittest.TestCase):
+    def setUp(self):
+        self.client = Client()
+        self.deploy = Deploy(self.client, os.path.join(FIXTURES, 'scanner'))
+
+    def test_collect_files(self):
+        self.assertEqual(self.deploy.collect_files(), [
+            'index.html',
+            'posts/hello-internet.html',
+            'posts/hello-world.html',
+            'posts/index.html',
+        ])
+
+    def test_collect_files_with_ignore_file(self):
+        deploy = Deploy(self.client, FIXTURES)
+        self.assertEqual(deploy.collect_files(), [
+            'scanner/index.html',
+            'scanner/posts/index.html',
+        ])

data/vendor/tests/test_file_scanner.py

@@ -0,0 +1,89 @@
+import os
+import tempfile
+import tarfile
+import unittest
+
+from rigid.file_scanner import scan, tar, Skipper
+
+FIXTURES = os.path.join(os.path.dirname(__file__), 'fixtures')
+
+
+class FileScannerTests(unittest.TestCase):
+    def test_scan_directory(self):
+        path = os.path.join(FIXTURES, 'scanner')
+        files = scan(path)
+
+        self.assertEqual(set(files), set([
+            'index.html',
+            'posts/hello-internet.html',
+            'posts/hello-world.html',
+            'posts/index.html',
+        ]))
+
+
+class TarTests(unittest.TestCase):
+    def test_tar(self):
+        fd = tempfile.NamedTemporaryFile()
+        path = os.path.join(FIXTURES, 'scanner')
+        tar(fd.name, ['posts/hello-internet.html', 'index.html'], path)
+
+        with tarfile.open(fd.name) as tarball:
+            self.assertEqual(tarball.getnames(), ['posts/hello-internet.html', 'index.html'])
+
+            post = tarball.getmember('index.html')
+            self.assertEqual(post.size, 13)
+            self.assertEqual(post.type, tarfile.REGTYPE)
+
+            post = tarball.getmember('posts/hello-internet.html')
+            self.assertEqual(post.size, 16)
+            self.assertEqual(post.type, tarfile.REGTYPE)
+
+        fd.close()
+
+
+class SkipperTests(unittest.TestCase):
+    def test_skipper_default_rules(self):
+        skipper = Skipper([])
+
+        rules = [
+            '.git',
+            '.DS_Store',
+            '.rigid.yaml',
+            '.rigid-*.yaml',
+
+            # Vim swap files
+            '*~',
+            '*.swp',
+            '*.swo',
+        ]
+
+        self.assertEqual(skipper.rules, rules)
+        self.assertEqual(skipper.DEFAULT_RULES, rules)
+
+    def test_skipper_component(self):
+        skipper = Skipper(['ignored'])
+
+        self.assertFalse(skipper.test('hello-world.html'))
+        self.assertFalse(skipper.test('ignored.html'))
+        self.assertTrue(skipper.test('ignored'))
+        self.assertTrue(skipper.test('ignored/index.html'))
+        self.assertTrue(skipper.test('deep/ignored/index.html'))
+        self.assertTrue(skipper.test('directory/ignored'))
+
+    def test_skipper_wildcard(self):
+        skipper = Skipper(['*.html'])
+
+        self.assertFalse(skipper.test('hello-html'))
+        self.assertFalse(skipper.test('html'))
+        self.assertTrue(skipper.test('test.html'))
+        self.assertTrue(skipper.test('testing/test.html'))
+
+    def test_callable(self):
+        skipper = Skipper(['ignored'])
+        self.assertFalse(skipper('ignored'))
+        self.assertTrue(skipper('not-ignored'))
+
+    def test_skipper_from_path(self):
+        path = os.path.join(FIXTURES, 'skipper')
+        skipper = Skipper.open(path)
+        self.assertEqual(skipper.rules, ['*.py', 'foo', 'bar'] + skipper.DEFAULT_RULES)

data/vendor/tests/utils.py

@@ -0,0 +1,78 @@
+import json
+from threading import Thread
+
+from six.moves import BaseHTTPServer
+
+
+class FakeServer(object):
+    def __init__(self):
+        self.requests = []
+        self.responses = []
+
+        self.status = 204
+        self.body = None
+
+        class Handler(BaseHTTPServer.BaseHTTPRequestHandler):
+            def dispatch(handler, method):
+                if len(self.responses) > 0:
+                    status = self.responses[len(self.requests)].get('status', self.status)
+                    body = self.responses[len(self.requests)].get('body', self.body)
+                else:
+                    status = self.status
+                    body = self.body
+
+                self.requests.append({
+                    'method': method,
+                    'path': handler.path,
+                    'headers': handler.headers,
+                })
+
+                handler.send_response(status)
+
+                if body is not None:
+                    body = json.dumps(body)
+                    handler.send_header('Content-Length', str(len(body)))
+                    handler.send_header('Content-Type', 'application/json')
+
+                handler.end_headers()
+
+                if body:
+                    handler.wfile.write(body)
+
+            def do_HEAD(handler):
+                handler.dispatch('HEAD')
+
+            def do_GET(handler):
+                handler.dispatch('GET')
+
+            def do_PUT(handler):
+                handler.dispatch('PUT')
+
+            def do_POST(handler):
+                handler.dispatch('POST')
+
+            def do_DELETE(handler):
+                handler.dispatch('DELETE')
+
+            def log_request(self, *args):
+                pass  # Disable default logging
+
+        self.server = BaseHTTPServer.HTTPServer(('localhost', 0), Handler)
+        self.server.timeout = 0.5
+        self.thread = Thread(target=self.server.serve_forever, args=(0.1,))
+        self.thread.daemon = True
+        self.thread.start()
+
+    @property
+    def url(self):
+        return 'http://{0}:{1}'.format(*self.server.server_address)
+
+    @property
+    def request(self):
+        """ Returns the last request """
+        return self.requests[-1]
+
+    def shutdown(self):
+        self.server.shutdown()
+        self.thread.join()
+        self.server.server_close()