tidas 0.1.0

data/lib/tidas/utilities/response_packager.rb

@@ -0,0 +1,36 @@
+module Tidas
+  module Utilities
+    module ResponsePackager
+
+      def self.package_response(response, data = nil)
+        if [500, 404].include? response.status
+          return InvalidResponse
+        end
+        begin
+          body = JSON.parse(response.body, symbolize_names: true)
+          return handle_result(body, data)
+        rescue JSON::ParserError
+          return InvalidResponse
+        end
+        return InvalidResponse
+      end
+
+      def self.handle_result(body, data = nil)
+        result_type = body.keys[0]
+        content = body[result_type]
+        case result_type
+          when :error_result
+            return ErrorResult.new(tidas_id:content[:tidas_id], errors:content[:errors])
+          when :successful_result
+            if content[:returned_data] != nil
+              return SuccessfulResult.new(tidas_id:content[:tidas_id], data:content[:returned_data], message:content[:message])
+            else
+              return SuccessfulResult.new(tidas_id:content[:tidas_id], data:data, message:content[:message])
+            end
+          else
+            return InvalidResponse
+        end
+      end
+    end
+  end
+end

data/lib/tidas/utilities/unpacker.rb

@@ -0,0 +1,93 @@
+require 'base64'
+
+module Tidas
+  module Utilities
+    class Unpacker
+
+      attr_accessor :parsed_data
+
+      def self.init_with_blob(blob)
+        Utilities::Unpacker.new( {blob: blob} )
+      end
+
+      def parse
+        pull_val_from_data(data_str)
+        @parsed_data
+      end
+
+      def data_str
+        Base64.decode64(@blob)
+      end
+
+      def to_s
+        @blob
+      end
+
+      def raw_blob_stripped_of_data
+        data_str.sub(data_bytes, '')
+      end
+
+      def blob_stripped_of_data
+        Base64.encode64(raw_blob_stripped_of_data)
+      end
+
+      private
+
+      def initialize(attributes)
+        @blob = attributes[:blob]
+        @parsed_data = {}
+        parse
+        raise StandardError, "Malformed Data Object" unless valid?
+      end
+
+      def pull_val_from_data(data)
+        return unless data[0]
+        type_char = data[0].unpack('C')[0]
+        type_str  = Utilities::SERIALIZATION_FIELDS[type_char]
+        field_len = data[1..4].unpack('I')[0]
+
+        val_end = 5+field_len-1
+        raw_val = data[5..val_end] 
+
+        val = extract_val(type_str, raw_val)
+
+        @parsed_data[type_str] = val
+
+        shorter_data = data[val_end+1..-1]
+        if shorter_data && shorter_data.length > 0
+          pull_val_from_data(shorter_data)
+        end
+      end
+
+      def extract_val(type, raw_val)
+        if type == :platform
+          raw_val.unpack('C')[0]
+        elsif type == :timestamp
+          time_data = raw_val.unpack('I')[0]
+          Time.at(time_data)
+        else
+          raw_val.unpack('C*').map{|e| e.chr }.join
+        end
+      end
+
+      def data_bytes
+        data_to_sign  = @parsed_data[:data_to_sign] || String.new
+        #identifier
+        type_byte     = [1].pack("C")
+        #datalen
+        len_bytes     = [data_to_sign.length].pack("L")
+
+        type_byte + len_bytes + data_to_sign
+      end
+
+      def valid?
+        return false if @parsed_data[:platform]   == nil
+        return false if @parsed_data[:timestamp]  == nil
+        return false if @parsed_data[:data_hash]  == nil
+        return false if @parsed_data[:signature]  == nil
+        true
+      end
+
+    end
+  end
+end

data/lib/tidas/utilities.rb

@@ -0,0 +1,14 @@
+module Tidas
+  module Utilities
+    SERIALIZATION_FIELDS = [
+      :platform,
+      :data_to_sign,
+      :timestamp,
+      :data_hash,
+      :signature,
+      :public_key_data
+    ]
+
+    TEST_DATA_STRING = %{AAEAAAAAAQUAAAB0b2tlbgIIAAAArjLCVQAAAAADFAAAAOampSqv22ZcJqGA8NycnekorHaIBEYAAAAwRAIgR318ZQZ2lZqMCtOmNZJeqaeFM4CXRK1MoV4V2nJoRlACIBQp4Aujc2Ks8t9ouJn//pVOhUFjqXhZltKBbz/GoSC9BUEAAAAELRQfUdYVN0zMrWllimOc9phemEbyqizT2NmPmnAnHrQnE+oTP0CLVFOZjDLhLdyoawcmMT6VurgDCkU9HW9zIg==}
+  end
+end

data/lib/tidas/version.rb

@@ -0,0 +1,4 @@
+module Tidas
+  # tidas version
+  VERSION = "0.1.0"
+end

data/lib/tidas.rb

@@ -0,0 +1,20 @@
+require 'tidas/utilities'
+require 'tidas/utilities/unpacker'
+require 'tidas/utilities/response_packager'
+
+require 'tidas/version'
+require 'tidas/configuration'
+
+require 'tidas/client'
+require 'tidas/error_result'
+require 'tidas/identity'
+require 'tidas/successful_result'
+
+require 'json'
+require 'faraday'
+
+module Tidas
+  def self.ping
+    Client.ping
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,198 @@
+require 'spec_helper'
+require 'tidas'
+
+describe Tidas::Client do
+  let(:client) {Tidas::Client}
+  let(:response_packager) {Tidas::Utilities::ResponsePackager}
+
+  describe "client" do
+    before {Tidas::Configuration.test_configure}
+    it "should return a Faraday::Connection object" do
+      expect(Tidas::Client.client.class).to be == Faraday::Connection
+    end
+
+    it "should always return the same connection object (singleton)" do
+      client_instance = Tidas::Client.client
+      expect(client_instance.object_id).to be == Tidas::Client.client.object_id
+    end
+  end
+
+  describe "server" do
+    it "should retrieve the server object from Tidas::Configuration" do
+      expect(Tidas::Configuration).to receive(:server)
+      client.server
+    end
+  end
+
+  describe "api_key" do
+    it "should retrieve the api_key object from Tidas::Configuration" do
+      expect(Tidas::Configuration).to receive(:api_key)
+      client.api_key
+    end
+  end
+
+  describe "application" do
+    it "should retrieve the application object from Tidas::Configuration" do
+      expect(Tidas::Configuration).to receive(:application)
+      client.application
+    end
+  end
+
+  describe "timeout" do
+    it "should retrieve the timeout object from Tidas::Configuration" do
+      expect(Tidas::Configuration).to receive(:timeout)
+      client.timeout
+    end
+  end
+
+  describe "ping" do
+    it "should call wrapped_get('ping')" do
+      expect(client).to receive(:wrapped_get).with('ping')
+      client.ping
+    end
+  end
+
+  describe "index_identities" do
+    it "should call wrapped_get('identities/index')" do
+      expect(client).to receive(:wrapped_get).with('identities/index')
+      client.index_identities
+    end
+  end
+
+  describe "get_identity(id)" do
+    let(:tidas_id) { 20 }
+    it "should call wrapped_get('identities/index') with an options hash containing an id" do
+      expect(client).to receive(:wrapped_get).with('identities/index', {tidas_id: tidas_id})
+      client.get_identity(tidas_id)
+    end
+  end
+
+  describe "enroll(data, id, overwrite)" do
+    describe "when body is valid" do
+      it "should call wrapped_post('identities/enroll') with a body hash" do
+        body = {enrollment_data:'test_data', tidas_id:'test_id', overwrite:true}
+        expect(client).to receive(:wrapped_post).with('identities/enroll', body)
+        client.enroll(body[:enrollment_data], body[:tidas_id], body[:overwrite])
+      end
+    end
+
+    describe "when body is empty" do
+      it "should still call wrapped_post('identities/enroll') with a body hash" do
+        body = {enrollment_data:nil}
+        expect(client).to receive(:wrapped_post).with('identities/enroll', body)
+        client.enroll(body[:enrollment_data], body[:tidas_id], body[:overwrite])
+      end
+    end
+  end
+
+  describe "validate(data, id)" do
+    describe "when data is not valid" do
+      it "should return a Tidas::ParameterError explaining that the data was invalid" do
+        expect { client.validate("test123", nil) }.to raise_error(Tidas::ParameterError, "Invalid data for request")
+      end
+    end
+
+    describe "when data is valid" do
+      it "should call wrapped_post('identities/validate') with a body hash and data" do
+        data_str = Tidas::Utilities::TEST_DATA_STRING
+        data_obj = Tidas::Utilities::Unpacker.init_with_blob(data_str)
+        body = {validation_data:data_str, tidas_id:'test_id'}
+        extracted_data = data_obj.parse[:data_to_sign]
+
+        expect(client).to receive(:wrapped_post).with('identities/validate', body, extracted_data)
+
+        client.validate(body[:validation_data], body[:tidas_id])
+      end
+    end
+  end
+
+  describe "deactivate(id)" do
+    it "should call wrapped_post('identities/deactivate') with a body containing a tidas id" do
+      body = {tidas_id: 'test123'}
+      expect(client).to receive(:wrapped_post).with('identities/deactivate', body)
+      client.deactivate(body[:tidas_id])
+    end
+  end
+
+  describe "activate(id)" do
+    it "should call wrapped_post('identities/activate') with a body containing a tidas id" do
+      body = {tidas_id: 'test123'}
+      expect(client).to receive(:wrapped_post).with('identities/activate', body)
+      client.activate(body[:tidas_id])
+    end
+  end
+
+  describe "wrapped_get(url, extra_params = nil)" do
+    describe "when service is reachable, and request does not time out" do
+      it "should call ResponsePackager to package the server's response" do
+        expect(client).to receive(:get) {true}
+        expect(response_packager).to receive(:package_response).with(true)
+        client.wrapped_get('test')
+      end
+
+      describe "with_extra params" do
+        it "should pass those too" do
+          expect(client).to receive(:get).with('test', {test: 'test'}) {true}
+          expect(response_packager).to receive(:package_response).with(true)
+          client.wrapped_get('test', {test: 'test'})
+        end
+      end
+    end
+
+    describe "when the service is reachable and the request does time out" do
+      it "should return a Tidas::TimeoutError object explaining the timeout" do
+        expect(client).to receive(:get) { raise Faraday::TimeoutError }
+        expect(client.wrapped_get('test')).to be == Tidas::TimeoutError
+      end
+    end
+
+    describe "when the service is unreachable and the request does time out" do
+      it "should return a Tidas::Connection object explaining the problem" do
+        expect(client.wrapped_get('test')).to be == Tidas::ConnectionError
+      end
+    end
+  end
+
+  describe "wrapped_post(url, body, data = nil)" do
+    let(:body) { {body: 'body'} }
+
+    describe "when service is reachable, and request does not time out" do
+      it "should call ResponsePackager to package the server's response" do
+        expect(client).to receive(:post).with('test', body) {true}
+        expect(response_packager).to receive(:package_response).with(true)
+        client.wrapped_post('test', body)
+      end
+
+      describe "with data" do
+        let(:data) { {data: 'data'} }
+        it "should pass the data along too" do
+          expect(client).to receive(:post).with('test', body) {true}
+          expect(response_packager).to receive(:package_response).with(true, data)
+          client.wrapped_post('test', body, data)
+        end
+      end
+    end
+
+    describe "when the service is reachable and the request does time out" do
+      it "should return a Tidas::TimeoutError object explaining the timeout" do
+        expect(client).to receive(:post).with('test', body) { raise Faraday::TimeoutError }
+        expect(client.wrapped_post('test', body)).to be == Tidas::TimeoutError
+      end
+    end
+
+    describe "when the service is unreachable and the request does time out" do
+      it "should return a Tidas::Connection object explaining the problem" do
+        expect(client.wrapped_post('test', body)).to be == Tidas::ConnectionError
+      end
+    end
+  end
+
+  describe "get(url, extra_params = nil)" do
+    
+  end
+
+  describe "post(url, body)" do
+
+  end
+
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'tidas'
+
+describe Tidas::Configuration do
+  let(:subject) {Tidas::Configuration}
+
+  describe "configure" do
+    it "should set server when given one" do
+      subject.configure(server:'foo.bar')
+      expect(subject.server).to be == 'foo.bar'
+    end
+
+    it "should set api_key when given one" do
+      subject.configure(api_key:'dffa40f7a0fc98a8fdd7ffff716d6620')
+      expect(subject.api_key).to be == 'dffa40f7a0fc98a8fdd7ffff716d6620'
+    end
+
+    it "should set application name when given one" do
+      subject.configure(application:'Javelin')
+      expect(subject.application).to be == 'Javelin'
+    end
+
+    it "should set timeout when given one" do
+      subject.configure(timeout:2)
+      expect(subject.timeout).to be == 2
+    end
+
+    context "using ENV variables" do
+      before do
+        subject.clear_configuration(:server)
+        subject.clear_configuration(:api_key)
+        subject.clear_configuration(:application)
+        subject.clear_configuration(:timeout)
+
+        ENV['tidas_server'] = 'test_server'
+        ENV['tidas_api_key'] = 'test_api_key'
+        ENV['tidas_application'] = 'test_application'
+        ENV['tidas_timeout'] = '5'
+      end
+
+      after do
+        ENV['tidas_server'] = nil
+        ENV['tidas_api_key'] = nil
+        ENV['tidas_application'] = nil
+        ENV['tidas_timeout'] = nil
+      end
+
+      it "should retrieve attributes from ENV if available" do
+        subject.configure
+
+        expect(subject.server).to be == 'test_server'
+        expect(subject.api_key).to be == 'test_api_key'
+        expect(subject.application).to be == 'test_application'
+        expect(subject.timeout).to be == 5
+      end
+    end
+  end
+
+  describe "server" do
+    before { subject.configure(server: 'test_val')}
+    it "should return @server'" do
+      expect(subject.server).to be == 'test_val'
+    end
+  end
+
+  describe "api_key" do
+    before { subject.configure(api_key: 'test_val')}
+    it "should return @api_key'" do
+      expect(subject.api_key).to be == 'test_val'
+    end
+  end
+
+  describe "application" do
+    before { subject.configure(application: 'test_val')}
+    it "should return @application'" do
+      expect(subject.application).to be == 'test_val'
+    end
+  end
+
+  describe "timeout" do
+    it "should return @timeout' when set" do
+      subject.configure(timeout: '2')
+      expect(subject.timeout).to be == 2
+    end
+
+    it "should return '20' when @timeout is not set" do
+      subject.clear_configuration(:timeout)
+      expect(subject.timeout).to be == 20
+    end
+  end
+
+  describe "clear_configuration" do
+    before { subject.configure(server: "test_server") }
+    it "should clear a named configuration @ivar" do
+      expect(subject.server).to be == "test_server"
+      subject.clear_configuration(:server)
+      expect(subject.server).to be == nil
+    end
+  end
+end

data/spec/error_result_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'tidas'
+
+describe Tidas::ErrorResult do
+  let(:result) {Tidas::ErrorResult.new(tidas_id: "id123", errors: %w[test1 test2 test3]) }
+  describe "success?" do
+    it "should return false" do
+      expect(result.success?).to be == false
+    end
+  end
+
+  describe "errors" do
+    it "should return an array of error strings" do
+      expect(result.errors.class).to be == Array
+      expect(result.errors.length).to be == 3
+      expect(result.errors).to be == ["test1", "test2", "test3"]
+    end
+  end
+
+  describe "to_json" do
+    it "should return the error in a digestable json format" do
+      expect(result.to_json).to be == %{{"error_result":{"tidas_id":"id123","errors":["test1","test2","test3"]}}}
+    end
+  end
+end

data/spec/identity_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+require 'tidas'
+
+describe Tidas::Identity do
+  let(:client)   { Tidas::Client }
+  let(:subject)  { Tidas::Identity }
+  let(:fake_id)  { 'test123' }
+  let(:data)     { 'data' }
+  let(:identity) { Tidas::Identity.new(id:fake_id, deactivated: false, app_name: 'Javelin', public_key: 'realKeyTrustMe') }
+
+  describe "index" do
+    it "should call Tidas::Client.index_identities and then process the response" do
+      expect(client).to receive(:index_identities) { true }
+      expect(subject).to receive(:process_identity_response).with(true)
+      subject.index
+    end
+  end
+
+  describe "get(id)" do
+    it "should call Tidas::Client.get_identity(id) and then process the response" do
+      expect(client).to receive(:get_identity).with(fake_id) { true }
+      expect(subject).to receive(:process_identity_response).with(true)
+      subject.get(fake_id)
+    end
+  end
+
+  describe "process_identity_response(resp)" do
+    describe "when response is successful" do
+      let(:resp) { Tidas::SuccessfulResult.new }
+      it "should call request_identities(resp)" do
+        expect(subject).to receive(:request_identities).with(resp)
+        subject.process_identity_response(resp)
+      end
+    end
+
+    describe "when a response is not successful" do
+      let(:resp) { Tidas::ErrorResult.new }
+      it "should call return the resp object" do
+        expect(subject.process_identity_response(resp).class).to be == Tidas::ErrorResult
+      end
+    end
+  end
+
+  describe "request_identities(resp)" do
+    let(:resp) { Object.new }
+    describe "when resp contains one identity object" do
+      let(:json_input) {{identities:[identity.to_hash_with_key]}.to_json}
+      it "should return a Tidas::SuccessfulResult object containing that identity" do
+        expect(resp).to receive(:data) {json_input}
+        output = subject.request_identities(resp)
+        expect(output.class).to be == Tidas::SuccessfulResult
+        expect(output.data.class).to be == Tidas::Identity
+      end
+    end
+
+    describe "when resp contains multiple identity objects" do
+      let(:json_input) {{identities:[identity.to_hash_with_key, identity.to_hash_with_key, identity.to_hash_with_key]}.to_json}
+      it "should return a Tidas::SuccessfulResult object containing that identity" do
+        expect(resp).to receive(:data) {json_input}
+        output = subject.request_identities(resp)
+        expect(output.class).to be == Tidas::SuccessfulResult
+        expect(output.data.class).to be == Array
+        expect(output.data[0].class).to be == Tidas::Identity
+      end
+    end
+  end
+
+  describe "enroll(attributes)" do
+    describe "when no options hash is passed" do
+      it "should call Tidas::Client.enroll(data, <nil>, <nil>)" do
+        expect(client).to receive(:enroll).with(data, nil, nil)
+        subject.enroll(data:data)
+      end
+    end
+
+    describe "when an options hash is passed" do
+      describe "when passing in a tidas_id" do
+        it "should call Tidas::Client.enroll(data, id, <nil>)" do
+          expect(client).to receive(:enroll).with(data, fake_id, nil)
+          subject.enroll(data:data, options:{tidas_id:fake_id})
+        end
+      end
+
+      describe "when passing in overwrite as true" do
+        it "should call Tidas::Client.enroll(data, nil, true)" do
+          expect(client).to receive(:enroll).with(data, nil, true)
+          subject.enroll(data:data, options:{overwrite:true})
+        end
+      end
+
+      describe "when passing in overwrite as anything else" do
+        it "should raise an error, explaining that you must only call the option with 'true'" do
+          expect{subject.enroll(data:data, options:{overwrite:'noodle'})}.to raise_error(ParameterError)
+        end
+      end
+    end
+  end
+
+  describe "validate(attributes)" do
+    it "should call Tidas::Client.validate(data, tidas_id)" do
+      expect(client).to receive(:validate).with(data, fake_id)
+      subject.validate(data:data, tidas_id:fake_id)
+    end
+  end
+
+  describe "deactivate(attributes)" do
+    it "should call Tidas::Client.deactivate(id)" do
+      expect(client).to receive(:deactivate).with(fake_id)
+      subject.deactivate(tidas_id:fake_id)
+    end
+  end
+
+  describe "activate(attributes)" do
+    it "should call Tidas::Client.activate(id)" do
+      expect(client).to receive(:activate).with(fake_id)
+      subject.activate(tidas_id:fake_id)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec'
+require 'tidas/version'
+
+require 'simplecov'
+SimpleCov.start
+
+include Tidas

data/spec/successful_result_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'tidas'
+
+describe Tidas::SuccessfulResult do
+  describe "success?" do
+    it "should return true" do
+      expect(Tidas::SuccessfulResult.new.success?).to be == true
+    end
+  end
+
+  
+end

data/spec/tidas_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'tidas'
+
+describe Tidas do
+  it "should have a VERSION constant" do
+    expect(subject.const_get('VERSION')).to_not be_empty
+  end
+end