authentise 0.0.1 → 0.1.0

data/lib/authentise/print.rb

@@ -0,0 +1,37 @@
+require "authentise/api/print"
+
+module Authentise
+  # Represents a streaming print iframe request
+  class Print
+    attr_accessor :model_url,
+                  :receiver_email,
+                  :print_value,
+                  :print_value_currency,
+                  :partner_job_id
+
+    def initialize(model_url: nil,
+                   receiver_email: nil,
+                   print_value: nil,
+                   print_value_currency: nil,
+                   partner_job_id: nil)
+      @model_url = model_url
+      @receiver_email = receiver_email
+      @print_value = print_value
+      @print_value_currency = print_value_currency
+      @partner_job_id = partner_job_id
+    end
+
+    def url
+      @url ||= begin
+        response = API::Print.create_token(
+          model_url: model_url,
+          receiver_email: receiver_email,
+          print_value: print_value,
+          print_value_currency: print_value_currency,
+          partner_job_id: partner_job_id,
+        )
+        response[:url]
+      end
+    end
+  end
+end

data/lib/authentise/session.rb

@@ -0,0 +1,25 @@
+require "authentise/api/users"
+
+module Authentise
+  # Represents a user's session to use the API with a session cookie
+  class Session
+    attr_reader :username,
+                :password,
+                :token
+
+    def initialize(username: nil,
+                   password: nil)
+      @username = username
+      @password = password
+    end
+
+    def create
+      response = API::Users.create_session(
+        username: username,
+        password: password,
+      )
+      @token = response[:token]
+      true
+    end
+  end
+end

data/lib/authentise/upload.rb

@@ -1,6 +1,7 @@
 require "authentise/api"
 
 module Authentise
+  # DEPRECATED
   class Upload
     attr_reader :stl_file, :email, :cents, :currency
 

data/lib/authentise/user.rb

@@ -0,0 +1,35 @@
+require "authentise/api"
+
+module Authentise
+  # Represents a user that can use the API
+  class User
+    attr_reader :email,
+                :name,
+                :username,
+                :password,
+                :url,
+                :uuid
+
+    def initialize(email: nil,
+                   name: nil,
+                   username: nil,
+                   password: nil)
+      @email = email
+      @name = name
+      @username = username
+      @password = password
+    end
+
+    def create
+      response = API::Users.create_user(
+        email: email,
+        name: name,
+        username: username,
+        password: password,
+      )
+      @url = response[:url]
+      @uuid = response[:uuid]
+      true
+    end
+  end
+end

data/lib/authentise/version.rb

@@ -1,3 +1,3 @@
 module Authentise
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/authentise.rb

@@ -1 +1,5 @@
 require "authentise/upload"
+require "authentise/model"
+require "authentise/user"
+require "authentise/session"
+require "authentise/print"

data/spec/api/print_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+require "authentise/api/print"
+
+describe Authentise::API::Print do
+
+  describe "create_token" do
+    it "returns a token_url" do
+      request_headers = {
+        "Accept" => "application/json",
+        "Content-Type" => "application/json",
+      }
+      request_body = {
+        api_key: "test",
+        model: "http://example.com/model/42",
+        receiver_email: "example@example.com",
+        print_value: 42,
+        print_value_currency: "EUR",
+        partner_job_id: 43,
+      }.to_json
+
+      response_headers = {
+        "X-Token-Location" => "http://example.com/token",
+      }
+
+      stub_request(:post, "https://print.authentise.com/token/")
+        .with(body: request_body, headers: request_headers)
+        .to_return(status: 201, headers: response_headers)
+
+      returned = Authentise::API::Print.create_token(
+        model_url: "http://example.com/model/42",
+        receiver_email: "example@example.com",
+        print_value: 42,
+        print_value_currency: "EUR",
+        partner_job_id: 43,
+      )
+
+      returned.must_equal(
+        url: "http://example.com/token",
+      )
+    end
+
+    it "raises errors" do
+      stub_request(:post, "https://print.authentise.com/token/")
+        .to_return(status: 400, body: "Some test error")
+
+      assert_raises Authentise::API::Error do
+        Authentise::API::Print.create_token(
+          model_url: "http://example.com/model/42",
+        )
+      end
+    end
+  end
+end

data/spec/api/users_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+require "authentise/api/users"
+
+describe Authentise::API::Users do
+  before do
+    @response_error_body = {
+      message: "Some test error",
+    }.to_json
+  end
+
+  describe "create_user" do
+    before do
+      @request_body = {
+        email: "test@example.com",
+        name: "Test User",
+        username: "testuser",
+        password: "password",
+      }
+      @request_headers = {
+        "Accept" => "application/json",
+        "Content-Type" => "application/x-www-form-urlencoded",
+      }
+      @response_body = {
+        name: "Test User",
+        username: "testuser",
+        uri: "https://example.com/user/1111",
+        uuid: "1111",
+      }.to_json
+    end
+
+    it "returns url and uuid" do
+      stub_request(:post, "https://users.authentise.com/users/")
+        .with(body: @request_body, headers: @request_headers)
+        .to_return(status: 201, body: @response_body)
+
+      returned = Authentise::API::Users.create_user(
+        email: "test@example.com",
+        name: "Test User",
+        username: "testuser",
+        password: "password",
+      )
+      returned.must_equal(
+        url: "https://example.com/user/1111",
+        uuid: "1111",
+      )
+    end
+
+    it "raises errors" do
+      stub_request(:post, "https://users.authentise.com/users/")
+        .with(body: @request_body, headers: @request_headers)
+        .to_return(status: 400, body: @response_error_body)
+
+      assert_raises Authentise::API::Error do
+        Authentise::API::Users.create_user(
+          email: "test@example.com",
+          name: "Test User",
+          username: "testuser",
+          password: "password",
+        )
+      end
+    end
+  end
+
+  describe "create_session" do
+    before do
+      @request_body = {
+        username: "testuser",
+        password: "password",
+      }
+      @request_headers = {
+        "Accept" => "application/json",
+        "Content-Type" => "application/x-www-form-urlencoded",
+      }
+      @response_headers = {
+        "Set-Cookie" => "session=f4242aef; " \
+                        "expires=Thu, 27-Apr-2017 08:49:20 GMT; " \
+                        "path=/; " \
+                        "domain=authentise.com",
+      }
+    end
+
+    it "returns a token" do
+      stub_request(:post, "https://users.authentise.com/sessions/")
+        .with(body: @request_body, headers: @request_headers)
+        .to_return(status: 201, body: "", headers: @response_headers)
+
+      returned = Authentise::API::Users.create_session(
+        username: "testuser",
+        password: "password",
+      )
+      returned.must_equal(
+        token: "f4242aef",
+      )
+    end
+
+    it "raises errors" do
+      stub_request(:post, "https://users.authentise.com/sessions/")
+        .to_return(status: 400, body: @response_error_body)
+
+      assert_raises Authentise::API::Error do
+        Authentise::API::Users.create_session(
+          username: "testuser",
+          password: "password",
+        )
+      end
+    end
+  end
+end

data/spec/api/warehouse_spec.rb

@@ -0,0 +1,330 @@
+require "spec_helper"
+require "authentise/api/warehouse"
+
+describe Authentise::API::Warehouse do
+  before do
+    @response_error_body = {
+      message: "Some test error",
+    }.to_json
+  end
+
+  describe "post_model" do
+    before do
+      @request_body = {
+        "name" => "Test",
+      }
+      @request_headers = {
+        "Accept" => "application/json",
+        "Content-Type" => "application/json",
+        "Cookie" => "session=f45k",
+      }
+      @response_headers = {
+        "Location" => "http://example.com/1",
+        "X-Upload-Location" => "http://example.com/2",
+      }
+    end
+
+    it "returns locations" do
+      stub_request(:post, "https://models.authentise.com/model/")
+        .with(body: @request_body.to_json, headers: @request_headers)
+        .to_return(status: 201, headers: @response_headers)
+
+      returned = Authentise::API::Warehouse.create_model(
+        name: "Test",
+        session_token: "f45k",
+      )
+      returned.must_equal(
+        model_url: "http://example.com/1",
+        upload_url: "http://example.com/2",
+      )
+    end
+
+    it "raises errors" do
+      stub_request(:post, "https://models.authentise.com/model/")
+        .with(body: @request_body.to_json, headers: @request_headers)
+        .to_return(status: 400, body: @response_error_body)
+
+      assert_raises Authentise::API::Error do
+        Authentise::API::Warehouse.create_model(
+          name: "Test",
+          session_token: "f45k",
+        )
+      end
+    end
+  end
+
+  describe "put_file" do
+    before do
+      @request_body = "contents of example.stl\n"
+    end
+
+    it "returns true" do
+      request_headers = {
+        'Content-Type' => 'application/octet-stream',
+      }
+      stub_request(:put, "https://example.com/")
+        .with(body: @request_body, headers: request_headers)
+        .to_return(status: 200)
+
+      response = Authentise::API::Warehouse.put_file(
+        url: "https://example.com/",
+        path: "spec/fixtures/example.stl",
+      )
+
+      response.must_equal(true)
+    end
+
+    it "raises errors" do
+      stub_request(:put, "https://example.com/")
+        .to_return(status: 400, body: @response_error_body)
+
+      assert_raises Authentise::API::Error do
+        Authentise::API::Warehouse.put_file(
+          url: "https://example.com/",
+          path: "spec/fixtures/example.stl",
+        )
+      end
+    end
+  end
+
+  describe "get_model" do
+    before do
+      @url = "https://models.authentise.com/model/424242/"
+      @request_headers = {
+        "Accept" => "application/json",
+        "Content-Type" => "application/json",
+        "Cookie" => "session=f56",
+      }
+      @response_body = {
+        name: "Test",
+        status: "processing",
+        snapshot: "http://example.com/snapshot",
+        content: "http://example.com/content",
+        "analyses.manifold" => true,
+        created: "2015-05-29 16:12:12.991340",
+        updated: "2015-05-29 16:12:13.991340",
+        parents: ["http://example.com/model/1", "http://example.com/model/2"],
+        children: ["http://example.com/model/1"],
+      }.to_json
+    end
+
+    it "returns a model" do
+      stub_request(:get, @url)
+        .with(headers: @request_headers)
+        .to_return(body: @response_body, status: 200)
+
+      response = Authentise::API::Warehouse.get_model(url: @url,
+                                                      session_token: "f56")
+      response.must_equal(
+        url: @url,
+        uuid: "424242",
+        name: "Test",
+        status: "processing",
+        snapshot_url: "http://example.com/snapshot",
+        content_url: "http://example.com/content",
+        manifold: true,
+        created_at: Time.local(2015, 5, 29, 16, 12, 12, 991_340),
+        updated_at: Time.local(2015, 5, 29, 16, 12, 13, 991_340),
+        parents_urls: ["http://example.com/model/1",
+                       "http://example.com/model/2"],
+        children_urls: ["http://example.com/model/1"],
+      )
+    end
+
+    it "accepts a uuid instead of a url" do
+      stub_request(:get, @url)
+        .with(headers: @request_headers)
+        .to_return(body: @response_body, status: 200)
+
+      response = Authentise::API::Warehouse.get_model(uuid: "424242",
+                                                      session_token: "f56")
+      response.must_equal(
+        url: @url,
+        uuid: "424242",
+        name: "Test",
+        status: "processing",
+        snapshot_url: "http://example.com/snapshot",
+        content_url: "http://example.com/content",
+        manifold: true,
+        created_at: Time.local(2015, 5, 29, 16, 12, 12, 991_340),
+        updated_at: Time.local(2015, 5, 29, 16, 12, 13, 991_340),
+        parents_urls: ["http://example.com/model/1",
+                       "http://example.com/model/2"],
+        children_urls: ["http://example.com/model/1"],
+      )
+    end
+
+    it "raises errors" do
+      stub_request(:get, @url)
+        .to_return(body: "", status: 404)
+
+      assert_raises Authentise::API::NotFoundError do
+        Authentise::API::Warehouse.get_model(url: @url,
+                                             session_token: "f56")
+      end
+    end
+  end
+
+  # describe "get_models" do
+  #   before do
+  #     @request_headers = {
+  #       "Accept" => "application/json",
+  #       "Content-Type" => "application/json",
+  #       "Cookie" => "session=e56",
+  #     }
+  #     @response_body = [{
+  #       name: "Test",
+  #       status: "processing",
+  #       snapshot: "http://example.com/snapshot",
+  #       content: "http://example.com/content",
+  #       "analyses.manifold" => true,
+  #       created: "2015-05-29 16:12:12.991340",
+  #       updated: "2015-05-29 16:12:13.991340",
+  #       parents: ["http://example.com/model/1", "http://example.com/model/2"],
+  #       children: ["http://example.com/model/1"],
+  #     }].to_json
+  #   end
+
+  #   it "returns models" do
+  #     stub_request(:get, "https://models.authentise.com/model/").
+  #       with(headers: @request_headers)
+  #       .to_return(body: @response_body, status: 200)
+
+  #     response = Authentise::API::Warehouse.get_models(session_token: "e56")
+  #     response.must_equal [
+  #       {
+  #         name: "Test",
+  #         status: "processing",
+  #         snapshot_url: "http://example.com/snapshot",
+  #         content_url: "http://example.com/content",
+  #         manifold: true,
+  #         created_at: Time.local(2015, 5, 29, 16, 12, 12, 991340),
+  #         updated_at: Time.local(2015, 5, 29, 16, 12, 13, 991340),
+  #         parents_urls: ["http://example.com/model/1",
+  #                        "http://example.com/model/2"],
+  #         children_urls: ["http://example.com/model/1"]
+  #       }
+  #     ]
+  #   end
+
+  #   it "adds query parameters" do
+  #     skip
+  #   end
+
+  #   it "raises errors" do
+  #     skip
+  #   end
+  # end
+
+  describe "create_snapshot" do
+    before do
+      @request_body = {
+        samples: 1,
+        layer: 10,
+        color: "#ff7f00",
+        height: 480,
+        width: 640,
+        x: 0,
+        y: 1,
+        z: 2,
+        u: 3,
+        v: 4,
+        w: 5,
+        callback: { url: "http://my.example.com/processing/done",
+                    method: "POST" },
+      }
+      @request_headers = {
+        "Accept" => "application/json",
+        "Content-Type" => "application/json",
+        "Cookie" => "session=f00",
+      }
+    end
+
+    it "returns snapshot data" do
+      response_headers = {
+        "Location" => "http://example.com/model/4242/snapshot/1212/",
+      }
+
+      stub_request(:post, "https://models.authentise.com/model/4242/snapshot/")
+        .with(body: @request_body, headers: @request_headers)
+        .to_return(status: 201, headers: response_headers)
+
+      response = Authentise::API::Warehouse.create_snapshot(
+        session_token: "f00",
+        model_uuid: "4242",
+        samples: 1,
+        layer: 10,
+        color: "#ff7f00",
+        height: 480,
+        width: 640,
+        x: 0,
+        y: 1,
+        z: 2,
+        u: 3,
+        v: 4,
+        w: 5,
+        callback: { url: "http://my.example.com/processing/done",
+                    method: "POST" },
+      )
+
+      response.must_equal(
+        url: "http://example.com/model/4242/snapshot/1212/",
+      )
+    end
+  end
+
+  describe "get_snapshot" do
+    before do
+      @request_headers = {
+        "Accept" => "application/json",
+        "Content-Type" => "application/json",
+        "Cookie" => "session=z90",
+      }
+      @response_body = {
+        status: "snapshot_rendering",
+        samples: 1,
+        layer: 1,
+        color: "#ff7f00",
+        height: 480,
+        width: 640,
+        x: 0,
+        y: 1,
+        z: 2,
+        u: 3,
+        v: 4,
+        w: 5,
+        slice_height: nil,
+        created: "2015-05-13 22:18:22.658536",
+        content: "https://example.com/content_url",
+      }.to_json
+    end
+
+    it "returns snapshot data" do
+      stub_request(:get, "https://models.authentise.com/model/42/snapshot/43/")
+        .with(headers: @request_headers)
+        .to_return(status: 200, body: @response_body)
+
+      response = Authentise::API::Warehouse.get_snapshot(
+        url: "https://models.authentise.com/model/42/snapshot/43/",
+        session_token: "z90",
+      )
+      response.must_equal(
+        status: "snapshot_rendering",
+        samples: 1,
+        layer: 1,
+        color: "#ff7f00",
+        height: 480,
+        width: 640,
+        x: 0,
+        y: 1,
+        z: 2,
+        u: 3,
+        v: 4,
+        w: 5,
+        slice_height: nil,
+        created_at: Time.local(2015, 05, 13, 22, 18, 22, 658_536),
+        content_url: "https://example.com/content_url",
+      )
+    end
+  end
+end

data/spec/api_spec.rb

@@ -3,7 +3,9 @@ require "spec_helper"
 describe Authentise::API do
   describe ".create_token" do
     it "returns a token from the API" do
-      stub_request(:get, "https://widget.sendshapes.com:3443/api3/api_create_partner_token?api_key=test")
+      api_url = "https://widget.sendshapes.com:3443/api3/" \
+                "api_create_partner_token?api_key=test"
+      stub_request(:get, api_url)
         .to_return(status: 200, body: '{"data":{"token":"meh"}}')
 
       Authentise::API.create_token.must_equal "meh"
@@ -18,12 +20,8 @@ describe Authentise::API do
                        "print_value_currency" => "EUR",
                        "receiver_email" => "example@example.com",
                        "stl_file" => "",
-                       "token"=>"meh"}
-      request_headers = { "Accept" => "application/json",
-                          "Accept-Encoding" => "gzip, deflate",
-                          "Content-Length" => "110",
-                          "Content-Type" => "application/x-www-form-urlencoded",
-                          "User-Agent" => "Ruby"}
+                       "token" => "meh" }
+      request_headers = { "Accept" => "application/json" }
 
       response_body = '{"data":{"ssl_token_link":"https://bah"}}'
 
@@ -57,13 +55,9 @@ describe Authentise::API do
 
   describe ".get_status" do
     it "returns a status hash" do
-      api_url = "https://widget.sendshapes.com:3443/api3/api_get_partner_print_status?api_key=test&token=meh"
-      request_body = { "api_key" => "test",
-                       "print_value" => "100",
-                       "print_value_currency" => "EUR",
-                       "receiver_email" => "example@example.com",
-                       "stl_file" => "",
-                       "token"=>"meh"}
+      api_url = "https://widget.sendshapes.com:3443/api3/" \
+                "api_get_partner_print_status?api_key=test&token=meh"
+
       response_body = {
         status: { code: "ok" },
         data: {
@@ -71,7 +65,7 @@ describe Authentise::API do
           printing_percentage: 20,
           minutes_left: nil,
           message: nil,
-        }
+        },
       }
 
       stub_request(:get, api_url)
@@ -82,7 +76,7 @@ describe Authentise::API do
         printing_job_status_name: "warming_up",
         printing_percentage: 20,
         minutes_left: nil,
-        message: nil
+        message: nil,
       )
     end
   end

data/spec/fixtures/example.stl

@@ -0,0 +1 @@
+contents of example.stl