add soledad sync test to `leap test`. closes #6431

3 files changed, 165 insertions, 4 deletions

diff --git a/tests/helpers/bonafide_helper.rb b/tests/helpers/bonafide_helper.rb
new file mode 100644
index 00000000..c84ea142
--- /dev/null
+++ b/tests/helpers/bonafide_helper.rb
@@ -0,0 +1,87 @@
+#
+# helper for the communication with the provider API for creating, authenticating, and deleting accounts.
+#
+
+class LeapTest
+
+  def assert_tmp_user
+    user = assert_create_user
+    assert_authenticate_user(user)
+    yield user if block_given?
+  rescue
+    # ^^ ensure here would eat any failed assertions
+    assert_delete_user(user)
+    raise
+  end
+
+  def api_url(path)
+    api = property('api')
+    "https://%{domain}:%{port}#{path}" % {
+      :domain   => api['domain'],
+      :port     => api['port']
+    }
+  end
+
+  #
+  # attempts to create a user account via the API,
+  # returning the user object if successful.
+  #
+  def assert_create_user
+    user = SRP::User.new
+    url = api_url("/1/users.json")
+    assert_post(url, user.to_params) do |body|
+      assert response = JSON.parse(body), 'response should be JSON'
+      assert response['ok'], 'creating a user should be successful'
+    end
+    user.ok = true
+    return user
+  end
+
+  #
+  # attempts to authenticate user. if successful,
+  # user object is updated with id and session token.
+  #
+  def assert_authenticate_user(user)
+    url = api_url("/1/sessions.json")
+    session = SRP::Session.new(user)
+    params = {'login' => user.username, 'A' => session.aa}
+    assert_post(url, params) do |response, body|
+      cookie = response['Set-Cookie'].split(';').first
+      assert(response = JSON.parse(body), 'response should be JSON')
+      assert(session.bb = response["B"], 'response should include "B"')
+      url = api_url("/1/sessions/login.json")
+      params = {'client_auth' => session.m, 'A' => session.aa}
+      options = {:headers => {'Cookie' => cookie}}
+      assert_put(url, params, options) do |body|
+        assert(response = JSON.parse(body), 'response should be JSON')
+        assert(response['M2'], 'response should include M2')
+        user.session_token = response['token']
+        user.id = response['id']
+        assert(user.session_token, 'response should include token')
+        assert(user.id, 'response should include user id')
+      end
+    end
+  end
+
+  #
+  # attempts to destroy a user account via the API.
+  #
+  def assert_delete_user(user)
+    if user && user.ok && user.id && user.session_token
+      url = api_url("/1/users/#{user.id}.json")
+      options = {:headers => {
+        "Authorization" => "Token token=\"#{user.session_token}\""
+      }}
+      delete(url, {}, options) do |body, response, error|
+        if response.code.to_i != 200
+          skip "It appears the web api is too old to support deleting users"
+        else
+          assert(response = JSON.parse(body), 'response should be JSON')
+          assert(response["success"], 'delete should be a success')
+          pass
+        end
+      end
+    end
+  end
+
+end
diff --git a/tests/helpers/soledad_sync.py b/tests/helpers/soledad_sync.py
new file mode 100755
index 00000000..54b6f34b
--- /dev/null
+++ b/tests/helpers/soledad_sync.py
@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+
+#
+# Test Soledad sync
+#
+# This script performs a slightly modified U1DB sync to the Soledad server and
+# returns whether that sync was successful or not.
+#
+# It takes three arguments:
+#
+#   uuid   -- uuid of the user to sync
+#   token  -- a valid session token
+#   server -- the url of the soledad server we should connect to
+#
+# For example:
+#
+#   soledad_sync.py f6bef0586fcfdb8705e26a58f2d9e580 uYO-4ucEJFksJ6afjmcYwIyap2vW7bv6uLxk0w_RfCc https://199.119.112.9:2323/user-f6bef0586fcfdb8705e26a58f2d9e580
+#
+
+import os
+import sys
+import tempfile
+import shutil
+import u1db
+
+from u1db.remote.http_target import HTTPSyncTarget
+
+#
+# monkey patch U1DB's HTTPSyncTarget to perform token based auth
+#
+
+def set_token_credentials(self, uuid, token):
+    self._creds = {'token': (uuid, token)}
+
+def _sign_request(self, method, url_query, params):
+    uuid, token = self._creds['token']
+    auth = '%s:%s' % (uuid, token)
+    return [('Authorization', 'Token %s' % auth.encode('base64')[:-1])]
+
+HTTPSyncTarget.set_token_credentials = set_token_credentials
+HTTPSyncTarget._sign_request = _sign_request
+
+#
+# Create a temporary local u1db replica and attempt to sync to it.
+# Returns a failure message if something went wrong.
+#
+
+def soledad_sync(uuid, token, server):
+    tempdir = tempfile.mkdtemp()
+    try:
+        db = u1db.open(os.path.join(tempdir, '%s.db' % uuid), True)
+        creds = {'token': {'uuid': uuid, 'token': token}}
+        db.sync(server, creds=creds, autocreate=False)
+    finally:
+        shutil.rmtree(tempdir)
+
+#
+# exit codes:
+#
+# 0 - OK
+# 1 - WARNING
+# 2 - ERROR
+#
+
+if __name__ == '__main__':
+    try:
+        uuid, token, server = sys.argv[1:]
+        result = soledad_sync(uuid, token, server)
+        if result is None:
+            exit(0)
+        else:
+            print(result)
+            exit(1)
+    except Exception as exc:
+        print(exc.message or str(exc))
+        exit(2)
diff --git a/tests/helpers/srp_helper.rb b/tests/helpers/srp_helper.rb
index 9f4d7f5b..0aa1b1fb 100644
--- a/tests/helpers/srp_helper.rb
+++ b/tests/helpers/srp_helper.rb
@@ -135,16 +135,14 @@ d15dc7d7b46154d6b6ce8ef4ad69b15d4982559b297bcf1885c529f566660e5
   class User
     include SRP::Util
 
-    attr_accessor :username
-    attr_accessor :password
-    attr_accessor :salt
-    attr_accessor :verifier
+    attr_accessor :username, :password, :salt, :verifier, :id, :session_token, :ok
 
     def initialize
       @username = "test_user_" + SecureRandom.urlsafe_base64(10).downcase.gsub(/[_-]/, '')
       @password = "password_" + SecureRandom.urlsafe_base64(10)
       @salt     = bigrand(4).hex
       @verifier = modpow(GENERATOR, private_key)
+      @ok       = false
     end
 
     def private_key