egree 0.0.1

data/lib/egree/serializers/case.rb

@@ -0,0 +1,22 @@
+require "json"
+require "egree/serializers/party"
+require "egree/serializers/document"
+
+module Egree
+  module Serializers
+    module Case
+      def self.serialize signature_case
+        JSON.pretty_generate to_api_hash(signature_case)
+      end
+
+      def self.to_api_hash signature_case
+        {
+          "Name" => signature_case.name,
+          "Documents" => signature_case.documents.map { |document| Document.to_api_hash(document) },
+          "Parties" => signature_case.parties.map { |party| Party.to_api_hash(party) },
+          "AllowedSignatureTypes" => signature_case.signature_types
+        }.merge(signature_case.reference_id.to_api_hash)
+      end
+    end
+  end
+end

data/lib/egree/serializers/document.rb

@@ -0,0 +1,21 @@
+require "egree/serializers/form_field"
+
+module Egree
+  module Serializers
+    module Document
+      def self.serialize document
+        JSON.pretty_generate to_api_hash(document)
+      end
+
+      def self.to_api_hash document
+        {
+          "Filename" => document.filename,
+          "Data" => document.data,
+          "ContentType" => document.content_type,
+          "Size" => document.size,
+          "FormFields" => document.form_fields.map { |form_field| FormField.to_api_hash(form_field) }
+        }
+      end
+    end
+  end
+end

data/lib/egree/serializers/form_field.rb

@@ -0,0 +1,16 @@
+module Egree
+  module Serializers
+    module FormField
+      def self.serialize form_field
+        JSON.pretty_generate to_api_hash(form_field)
+      end
+
+      def self.to_api_hash form_field
+        {
+          "Name" => form_field.name,
+          "Value" => form_field.value
+        }
+      end
+    end
+  end
+end

data/lib/egree/serializers/party.rb

@@ -0,0 +1,17 @@
+module Egree
+  module Serializers
+    module Party
+      def self.serialize party
+        JSON.pretty_generate to_api_hash(party)
+      end
+
+      def self.to_api_hash party
+        {
+          "Name" => party.name,
+          "EmailAddress" => party.email,
+          "SocialSecurityNumber" => party.social_security_number
+        }
+      end
+    end
+  end
+end

data/lib/egree/serializers/reference_id.rb

@@ -0,0 +1,18 @@
+require "json"
+
+module Egree
+  module Serializers
+    module ReferenceId
+      def self.serialize reference_id
+        JSON.pretty_generate to_api_hash(reference_id)
+      end
+
+      def self.to_api_hash reference_id
+        {
+          "CaseReferenceId" => reference_id.to_s
+        }
+      end
+    end
+  end
+end
+

data/lib/egree/version.rb

@@ -0,0 +1,3 @@
+module Egree
+  VERSION = "0.0.1"
+end

data/spec/egree/case_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+require "egree/case"
+
+module Egree
+  RSpec.describe Case do
+    let :signature_case do
+      Case.new "Agreement", Case.signature_types
+    end
+
+    it "requires a name" do
+      expect(signature_case.name).to eq "Agreement"
+    end
+
+    specify ".generate_reference_id" do
+      expect(Egree::ReferenceId).to receive(:generate).and_return "very-random"
+
+      expect(Case.generate_reference_id).to eq "very-random"
+    end
+
+    describe "#reference_id" do
+      it "creates a unique reference_id" do
+        expect(Case).to receive(:generate_reference_id).and_return "very-random"
+
+        expect(signature_case.reference_id).to eq "very-random"
+      end
+
+      it "does not change the reference_id after created" do
+        last_id = signature_case.reference_id
+
+        expect(signature_case.reference_id).to eq last_id
+      end
+
+      it "does not share reference_id between instances" do
+        expect(signature_case.reference_id).to_not eq Case.new("Agreement", Case.signature_types).reference_id
+      end
+    end
+
+    describe "signature types" do
+      it "requires at least one valid signature type" do
+        signature_case = Case.new "Agreement", Case.signature_types.first
+
+        expect(signature_case.signature_types).to eq [ Case.signature_types.first ]
+      end
+
+      it "throws an error if it is an unknown signature type" do
+        expect{ Case.new("Agreement", "unknown type") }.to raise_error(ArgumentError)
+      end
+    end
+
+    it "adds a party" do
+      signature_case = Case.new "Agreement", Case.signature_types
+
+      party = double "Party"
+      signature_case.add_party party
+
+      expect(signature_case.parties).to eq [party]
+    end
+
+    it "adds a document" do
+      signature_case = Case.new "Agreement", Case.signature_types
+
+      document = double "Document"
+      signature_case.add_document document
+
+      expect(signature_case.documents).to eq [document]
+    end
+
+    describe "#to_json" do
+      it "uses Serializers::Case" do
+        expect(signature_case.to_json).to eq Serializers::Case.serialize(signature_case)
+      end
+    end
+  end
+end

data/spec/egree/client/create_case_spec.rb

@@ -0,0 +1,62 @@
+require "luhn"
+require "spec_helper"
+
+require "egree/client"
+require "egree/case"
+require "egree/document"
+require "egree/party"
+
+module Egree
+  describe Egree::Client do
+    describe "#create_case" do
+      let :client do
+        Egree::Client.new ENV["EGREE_USERNAME"], ENV["EGREE_PASSWORD"], :test
+      end
+
+      it "sends the create case comamnd with a json representation of the case" do
+        allow(client).to receive :post
+
+        signature_case = double "Case", to_json: "case-json"
+
+        client.create_case signature_case
+
+        expect(client).to have_received(:post).with "/apiv1/createcasecommand", "case-json"
+      end
+
+      describe "with a valid case", vcr: { cassette_name: "Egree_Client/_create_case/valid_case" } do
+        it "returns a successful result object" do
+          signature_case = Egree::Case.new "Agreement", ["touch"]
+          signature_case.add_party Egree::Party.new_with_attributes({
+            name: "First Last",
+            email: "name@example.com",
+            social_security_number: Luhn::CivicNumber.generate
+          })
+          signature_case.add_document Egree::Document.new(File.join(Dir.pwd, "spec/fixtures/agreement.pdf"))
+
+          result = client.create_case signature_case
+
+          expect(result.success?).to be true
+        end
+      end
+
+      describe "with an invalid case" do
+        it "returns a error result object", vcr: { cassette_name: "Egree_Client/_create_case/invalid_case" } do
+          signature_case = Egree::Case.new "Agreement", ["touch"]
+
+          result = client.create_case signature_case
+
+          expect(result.success?).to be false
+        end
+
+        it "includes the error message", vcr: true do
+          signature_case = Egree::Case.new "Agreement", ["touch"]
+          signature_case.add_document Egree::Document.new(File.join(Dir.pwd, "spec/fixtures/agreement.pdf"))
+
+          result = client.create_case signature_case
+
+          expect(result.errors[0]).to eq "E041 At least one signer is required."
+        end
+      end
+    end
+  end
+end

data/spec/egree/client/get_case_url_spec.rb

@@ -0,0 +1,84 @@
+require "luhn"
+require "spec_helper"
+
+require "egree/client"
+require "egree/case"
+require "egree/document"
+require "egree/party"
+
+module Egree
+  describe Egree::Client do
+    let :client do
+      Egree::Client.new ENV["EGREE_USERNAME"], ENV["EGREE_PASSWORD"], :test
+    end
+
+    describe "#get_case_url" do
+      it "sends the getviewcaseurl query with the case reference id" do
+        allow(client).to receive :post
+
+        signature_case = double "Case", to_json: "reference-id-json"
+
+        client.get_case_url signature_case
+
+        expect(client).to have_received(:post).with "/apiv1/getviewcaseurlquery", "reference-id-json"
+      end
+
+      describe "when the case exists", vcr: { cassette_name: "Egree_Client/_get_case_url/case_exists" } do
+        let :reference_id do
+          Egree::Case.generate_reference_id
+        end
+
+        before do
+          create_case reference_id
+        end
+
+        describe "result" do
+          it "is successfull" do
+            result = client.get_case_url reference_id
+
+            expect(result.success?).to be true
+          end
+
+          it "has the url as the response" do
+            result = client.get_case_url reference_id
+
+            expect(result.response).to match "https://test.underskrift.se"
+          end
+        end
+      end
+
+      describe "when there is no matching case" do
+        describe "result", vcr: { cassette_name: "Egree_Client/_get_case_url/case_missing" } do
+          it "is not successfull" do
+            result = client.get_case_url "missing-case"
+
+            expect(result.success?).to be false
+          end
+
+          it "has the error" do
+            result = client.get_case_url "missing-case"
+
+            expect(result.errors[0]).to eq "E030 User is not creator of case."
+          end
+        end
+      end
+    end
+
+    private
+
+    def create_case reference_id = nil
+      signature_case = Egree::Case.new "Agreement", ["touch"]
+      signature_case.add_party Egree::Party.new_with_attributes({
+        name: "First Last",
+        email: "name@example.com",
+        social_security_number: Luhn::CivicNumber.generate
+      })
+      signature_case.add_document Egree::Document.new(File.join(Dir.pwd, "spec/fixtures/agreement.pdf"))
+
+      signature_case.reference_id = reference_id if reference_id
+
+      client.create_case signature_case
+    end
+  end
+end
+

data/spec/egree/client_spec.rb

@@ -0,0 +1,125 @@
+require "spec_helper"
+require "egree/client"
+
+RSpec.describe Egree::Client do
+  let :client do
+    Egree::Client.new "admin", "secret"
+  end
+
+  it "instantiates with username and password" do
+    expect(client.username).to eq "admin"
+    expect(client.password).to eq "secret"
+  end
+
+  describe "host" do
+    it "defaults to the production environment" do
+      expect(client.host).to eq "app.egree.com"
+    end
+
+    it "can be set to the test environment" do
+      test_host = "test.underskrift.se"
+
+      expect(Egree::Client.new("admin", "secret", :test).host).to eq test_host
+
+      client = Egree::Client.new "admin", "secret"
+      client.environment = :test
+
+      expect(client.host).to eq test_host
+    end
+  end
+
+  describe "#post" do
+    it "it sends the json as the request body" do
+      stub_request(:post, "https://admin:secret@app.egree.com/some/path").with({
+        body: '{ "key": "value" }'
+      })
+
+      client.post "/some/path", '{ "key": "value" }'
+    end
+
+    describe "headers" do
+      it "sets application/json with utf8 charset" do
+        stub_request(:post, "https://admin:secret@app.egree.com/some/path").with({
+          headers: { "content-type" => "application/json; charset=utf-8" }
+        })
+
+        client.post "/some/path", '{ "key": "value" }'
+      end
+    end
+
+    describe "with a successful response" do
+      before do
+        stub_request(:post, "https://admin:secret@app.egree.com/some/path").to_return({
+          status: 200,
+          body: '{ "result": "Success" }'
+        })
+      end
+
+      describe "result" do
+        it "is successfull" do
+          result = client.post "/some/path"
+
+          expect(result.success?).to be true
+        end
+
+        it "parses the response json" do
+          result = client.post "/some/path"
+
+          expect(result.response).to eq("result" => "Success")
+        end
+
+        it "handles simple string bodies" do
+          stub_request(:post, "https://admin:secret@app.egree.com/some/path").to_return({
+            status: 200,
+            body: "a string response"
+          })
+
+          result = client.post "/some/path"
+
+          expect(result.response).to eq "a string response"
+        end
+      end
+    end
+
+    describe "with a error response" do
+      before do
+        stub_request(:post, "https://admin:secret@app.egree.com/some/path").to_return({
+          status: 500,
+          body: "<html><p>Error message</p><p>Another error</p></html>"
+        })
+      end
+
+      it "returns a error result" do
+        result = client.post "/some/path"
+
+        expect(result.success?).to be false
+      end
+
+      it "parses the error messages from the html body" do
+        result = client.post "/some/path"
+
+        expect(result.errors).to eq [ "Error message", "Another error" ]
+      end
+    end
+  end
+
+  describe "#connection" do
+    it "looks lika a faraday connection" do
+      expect(client.connection).to be_kind_of Faraday::Connection
+    end
+
+    it "runs over https" do
+      expect(client.connection.scheme).to eq "https"
+    end
+
+    it "points to the host" do
+      expect(client.connection.host).to eq client.host
+    end
+
+    describe "authentication" do
+      it "uses basic auth" do
+        expect(client.headers["Authorization"]).to eq "Basic YWRtaW46c2VjcmV0"
+      end
+    end
+  end
+end