wcc-data 0.1.0

data/lib/wcc/data/rest_endpoint.rb

@@ -0,0 +1,33 @@
+module WCC::Data
+
+  class RESTEndpoint
+    attr_reader :service
+
+    def initialize(args={})
+      @service = args[:service]
+    end
+
+    def index(options={})
+      service.get(options)
+    end
+
+    def show(id, options={})
+      service.get(options.merge(uri: id.to_s))
+    end
+
+    def create(attrs, options={})
+      service.post(options.merge(body: attrs))
+    end
+
+    def update(id, attrs, options={})
+      service.patch(options.merge(uri: id.to_s, body: attrs))
+    end
+
+    def destroy(id, options={})
+      service.delete(options.merge(uri: id.to_s))
+    end
+
+  end
+
+end
+

data/lib/wcc/data/service.rb

@@ -0,0 +1,55 @@
+module WCC::Data
+  class Service
+    attr_reader :uri, :connection
+
+    VERBS = Set.new(%i[get post put patch delete])
+
+    def initialize(args={})
+      @uri = URI(args.fetch(:uri) { "" })
+      @connection = args.fetch(:connection) { nil }
+    end
+
+    def merge(arg=nil)
+      right = WCC::Data.Service(arg)
+      self.class.new(
+        uri: merge_uris(uri, right.uri),
+        connection: right.connection || connection
+      )
+    end
+
+    VERBS.each do |verb|
+      define_method(verb) do |options|
+        Response.new(
+          connection.run_request(
+            verb,
+            merge_uris(uri, options.fetch(:uri) { "" }),
+            options[:body],
+            options[:headers]
+          ) do |request|
+            request.params.update(options[:params]) if options[:params]
+          end
+        )
+      end
+    end
+
+    private
+
+    def merge_uris(uri1, uri2)
+      URI(uri1) + URI(uri2)
+    end
+
+  end
+
+  def self.Service(hash_or_object)
+    case hash_or_object
+    when Service
+      hash_or_object
+    when Hash
+      Service.new(hash_or_object)
+    when NilClass
+      Service.new
+    else
+      raise ArgumentError
+    end
+  end
+end

data/lib/wcc/data/version.rb

@@ -0,0 +1,5 @@
+module WCC
+  module Data
+    VERSION = "0.1.0"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+SPEC_DIR = File.dirname(__FILE__)
+FIXTURES_DIR = File.join(SPEC_DIR, "fixtures")
+
+$LOAD_PATH.unshift File.join(SPEC_DIR, "..", "lib")
+$LOAD_PATH.unshift SPEC_DIR
+
+require 'dotenv'
+Dotenv.load
+
+require 'wcc/data'
+require 'sidekiq'
+
+Dir[File.join(SPEC_DIR, "support", "*.rb")].each do |support_file|
+  require "support/#{File.basename(support_file, ".rb")}"
+end
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+end

data/spec/support/inheritable_class_attribute_examples.rb

@@ -0,0 +1,16 @@
+shared_examples_for :inheritable_class_attributes do |name|
+  let(:subclass) { Class.new(subject) }
+
+  it "inherited value is the same as parent class" do
+    subject.send(:instance_variable_set, :"@#{name}", foo: :bar)
+    expect(subject.send(name)).to eq(foo: :bar)
+    expect(subclass.send(name)).to eq(foo: :bar)
+  end
+
+  it "inherited reference is unique from the parent class" do
+    subject.send(:instance_variable_set, :"@#{name}", foo: :bar)
+    subclass.send(name)[:bar] = :baz
+    expect(subject.send(name)).to eq(foo: :bar)
+  end
+end
+

data/spec/wcc/data/config_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe WCC::Data::Config::Application do
+  let(:unit) { WCC::Data::Config::Application }
+  subject { unit.new(:name) }
+
+  describe "#initialize" do
+    it "takes a single name symbol and stores in @name" do
+      obj = unit.new(:name)
+      expect(obj.name).to eq(:name)
+    end
+
+    it "takes a connection option and stores it in @connection" do
+      obj = unit.new(:name, connection: "foo")
+      expect(obj.connection).to eq("foo")
+    end
+
+    it "sets to a blank Faraday::Connection" do
+      obj = unit.new(:name)
+      expect(obj.connection).to be_a(Faraday::Connection)
+    end
+  end
+
+  describe "#uri=" do
+    it "converts a string to a URI and stores in @uri" do
+      subject.uri = "http://test"
+      expect(subject.uri).to be_a(URI)
+      expect(subject.uri.scheme).to eq("http")
+    end
+
+    it "uses the URI object if set with a URI" do
+      subject.uri = test_value = URI("http://test")
+      expect(subject.uri).to eq(test_value)
+    end
+  end
+
+  describe "#service" do
+    before(:each) do
+      subject.uri = "http://test.com/"
+    end
+
+    it "returns a service object based on the URI" do
+      obj = subject.service
+      expect(obj).to be_a(WCC::Data::Service)
+      expect(obj.uri).to eq(subject.uri)
+    end
+
+    it "passes the application connection through to the service" do
+      obj = subject.service
+      expect(obj.connection).to eq(subject.connection)
+    end
+  end
+
+  describe "@connection" do
+    it "gets and sets" do
+      subject.connection = "foo"
+      expect(subject.connection).to eq("foo")
+    end
+  end
+end
+
+describe WCC::Data::Config do
+  let(:unit) { WCC::Data::Config }
+  subject { unit.new }
+
+
+  describe "#applications" do
+    it "returns a hash" do
+      expect(subject.applications).to be_a(Hash)
+    end
+
+    it "defaults empty keys to an application" do
+      expect(subject.applications[:foo]).to be_a(WCC::Data::Config::Application)
+    end
+
+    it "contains a default entry for :nucleus" do
+      expect(subject.applications[:nucleus].uri).to eq(
+        URI(ENV['NUCLEUS_URL'])
+      )
+    end
+
+    context "with APP_CLIENT_ID and APP_CLIENT_SECRET ENV vars set" do
+      after do
+        ENV['APP_CLIENT_ID'] = ENV['APP_CLIENT_SECRET'] = nil
+      end
+
+      it "sets the connection's basic auth for nucleus" do
+        ENV['APP_CLIENT_ID'] = "test"
+        ENV['APP_CLIENT_SECRET'] = "value"
+
+        header = subject.applications[:nucleus].connection.headers["Authorization"]
+
+        expect(header)
+          .to eq(Faraday::Request::BasicAuthentication.header("test", "value"))
+      end
+    end
+
+    context "with APP_CLIENT_ID and APP_CLIENT_SECRET not both set" do
+      it "does not set the basic auth for nucleus" do
+        header = subject.applications[:nucleus].connection.headers["Authorization"]
+
+        expect(header).to be_nil
+      end
+    end
+  end
+
+  describe "#apps alias" do
+    it "aliases to #applications" do
+      expect(subject.apps).to eq(subject.applications)
+    end
+  end
+
+end

data/spec/wcc/data/enumerated_type_spec.rb

@@ -0,0 +1,176 @@
+require "spec_helper"
+
+describe WCC::Data::EnumeratedType do
+
+  context "with configured attributes" do
+    let(:type) {
+      Class.new(described_class) do
+        attributes :test1, :test2
+      end
+    }
+    let(:object) { type.new(data) }
+    let(:data) {
+      {
+        test1: "test data 1",
+        test2: "test data 2",
+        ignored: "",
+      }
+    }
+
+    it "adds a method for all arguments passed" do
+      expect(object).to respond_to(:test1)
+      expect(object).to respond_to(:test2)
+    end
+
+    it "sets values from initialize hash" do
+      expect(object.test1).to eq("test data 1")
+      expect(object.test2).to eq("test data 2")
+    end
+
+    describe "::defined_attributes" do
+      it "should return attributes" do
+        expect(type.defined_attributes).to eq([:test1, :test2])
+      end
+    end
+  end
+
+  context "with child classes" do
+    let(:parent) {
+      Class.new(described_class) do
+        attributes :attr1
+        attributes :attr2
+      end
+    }
+    let(:child) {
+      Class.new(parent) do
+        attributes :attr3, :attr4
+      end
+    }
+    let(:parent_object) { parent.new(data) }
+    let(:child_object) { child.new(data) }
+    let(:data) {
+      {
+        attr1: "data1",
+        attr2: "data2",
+        attr3: "data3",
+        attr4: "data4",
+      }
+    }
+
+    describe "parent class" do
+      it "does not include child attributes" do
+        expect(parent_object).to_not respond_to(:attr3)
+        expect(parent_object).to_not respond_to(:attr4)
+      end
+
+      it "includes both attributes" do
+        expect(parent_object).to respond_to(:attr1)
+        expect(parent_object).to respond_to(:attr2)
+      end
+
+      it "sets both attributes on initialize" do
+        expect(parent_object.attr1).to eq("data1")
+        expect(parent_object.attr2).to eq("data2")
+      end
+    end
+
+    describe "child class" do
+      it "includes all defined_attributes" do
+        expect(child.defined_attributes).to eq([:attr1, :attr2, :attr3, :attr4])
+      end
+
+      it "includes parent attributes and child attributes readers" do
+        expect(child_object.attr1).to eq("data1")
+        expect(child_object.attr2).to eq("data2")
+        expect(child_object.attr3).to eq("data3")
+        expect(child_object.attr4).to eq("data4")
+      end
+    end
+
+  end
+
+  context "with db, matches?, and attributes configured" do
+    let(:type) {
+      Class.new(described_class) do
+        attributes :id, :name, :key
+
+        def matches?(value)
+          [id, key].include?(value)
+        end
+
+        def self.db
+          [
+            { id: 1, name: "One", key: :one },
+            { id: 2, name: "Two", key: :two },
+            { id: 3, name: "Three", key: :three },
+            { id: 4, name: "Four", key: :three },
+          ]
+        end
+      end
+    }
+
+    describe "::[]" do
+      it "returns an instance of type if match found" do
+        expect(type[1]).to be_a(type)
+      end
+
+      it "returns nil if no match found" do
+        expect(type[:nil]).to be_nil
+      end
+
+      it "returns first match when multiple matches present" do
+        expect(type[:three]).to eq(type.all[2])
+      end
+    end
+
+    describe "::all" do
+      it "returns instances of EnumeratedType for each item in db" do
+        expect(type.all.size).to eq(4)
+        expect(type.all[0]).to be_a(type)
+        expect(type.all[1]).to be_a(type)
+        expect(type.all[2]).to be_a(type)
+        expect(type.all[3]).to be_a(type)
+      end
+
+      it "sets attributes for each record properly" do
+        expect(type.all[0].id).to eq(1)
+        expect(type.all[0].name).to eq("One")
+        expect(type.all[0].key).to eq(:one)
+        expect(type.all[1].key).to eq(:two)
+        expect(type.all[2].key).to eq(:three)
+      end
+
+      it "caches the results" do
+        expect(type.all[0].object_id).to eq(type.all[0].object_id)
+      end
+    end
+
+    describe "::reset" do
+      it "clears out all and forces new object creation" do
+        first_id = type.all[0].object_id
+        type.reset
+        expect(type.all[0].object_id).to_not eq(first_id)
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "allows passing no argument" do
+      expect { described_class.new }.to_not raise_error
+    end
+  end
+
+  describe "::db" do
+    it "raises NotImplementedError with instructions" do
+      expect { described_class.db }.to raise_error(NotImplementedError, /subclass/i)
+    end
+  end
+
+  describe "#matches?" do
+    it "raises NotImplementedError with instructions" do
+      object = described_class.new({})
+      expect { object.matches?(:val) }.to raise_error(NotImplementedError, /subclass/i)
+    end
+  end
+
+end

data/spec/wcc/data/faraday_client_app_token_auth_spec.rb

@@ -0,0 +1,224 @@
+require 'spec_helper'
+
+RSpec.describe WCC::Data::FaradayClientAppTokenAuth do
+  let(:app) { spy(:application) }
+
+  describe WCC::Data::FaradayClientAppTokenAuth::RedisCache do
+    let(:connection) { instance_spy(Redis) }
+    let(:connection_lambda) { -> (&blk) { blk.call(connection) } }
+
+    describe "#initialize" do
+      it "requires a callable for Redis connection" do
+        expect { described_class.new }.to raise_error(ArgumentError)
+        obj = described_class.new(connection_lambda)
+        expect(obj.connection).to eq(connection_lambda)
+      end
+
+      it "allows setting a :cache_key option to change the token store" do
+        obj = described_class.new(connection_lambda, cache_key: "store")
+        expect(obj.cache_key).to eq("store")
+      end
+
+      it "defaults to the value of the DEFAULT_CACHE_KEY constant" do
+        obj = described_class.new(connection_lambda)
+        expect(obj.cache_key).to eq(described_class::DEFAULT_CACHE_KEY)
+      end
+    end
+
+    describe "#[]" do
+      subject(:cache) { described_class.new(connection_lambda) }
+
+      it "returns HGET on the cache_key for the specified field" do
+        expect(connection)
+          .to receive(:hget).with(cache.cache_key, "example.com").and_return("123abc")
+        expect(cache["example.com"]).to eq("123abc")
+      end
+    end
+
+    describe "#[]=" do
+      subject(:cache) { described_class.new(connection_lambda) }
+
+      it "does HSET on the cache_key for the specified field and value" do
+        cache["example.com"] = "abc123"
+        expect(connection)
+          .to have_received(:hset).with(cache.cache_key, "example.com", "abc123")
+      end
+
+      context "with a nil value" do
+        it "does HDEL on the cache_key for the specified field" do
+          cache["example.com"] = nil
+          expect(connection)
+            .to have_received(:hdel).with(cache.cache_key, "example.com")
+        end
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "takes an app as param one and sets to @app" do
+      obj = described_class.new(:app)
+      expect(obj.send(:instance_variable_get, :@app)).to eq(:app)
+    end
+
+    it "takes a :cache option" do
+      obj = described_class.new(:app, cache: :cache)
+      expect(obj.cache).to eq(:cache)
+    end
+
+    it "takes a :token_factory option" do
+      obj = described_class.new(:app, token_factory: :factory)
+      expect(obj.token_factory).to eq(:factory)
+    end
+
+    it "defaults :cache option to an instance of RedisCache" do
+      obj = described_class.new(:app)
+      expect(obj.cache).to be_a(described_class::RedisCache)
+      expect(obj.cache.connection).to eq(Sidekiq.method(:redis))
+    end
+
+    it "defaults :token_factory option to a callable" do
+      obj = described_class.new(:app)
+      expect(obj.token_factory).to respond_to(:call)
+    end
+
+    describe "default token_factory" do
+      it "returns #token property from a Nucleus::ClientAppToken create" do
+        token = instance_spy(WCC::Data::Nucleus::ClientAppToken)
+
+        expect(WCC::Data::Nucleus::ClientAppToken)
+          .to receive(:create).with(hostname: "example.com").and_return(token)
+        expect(token).to receive(:token).and_return("abc123")
+        expect(described_class.new(:app).token_factory.("example.com"))
+          .to eq("abc123")
+      end
+    end
+  end
+
+  describe "#call" do
+    let(:app) { spy(:application) }
+    subject(:auth) { described_class.new(app) }
+    let(:env) {
+      {
+        url: URI("http://example.com"),
+        request_headers: {},
+      }
+    }
+
+    before do
+      allow(auth)
+        .to receive(:token_for).with("example.com").and_return("abc123")
+    end
+
+    it "sets env's Authorization header using value from #token_for" do
+      auth.call(env)
+      expect(env[:request_headers]["Authorization"])
+        .to eq("Bearer abc123")
+    end
+
+    it "calls @app with env" do
+      expect(app).to receive(:call).with(env)
+      auth.call(env)
+    end
+
+    it "adds an on_complete handler to @app" do
+      allow(app).to receive(:call).and_return(app).ordered
+      expect(app).to receive(:on_complete).ordered
+      auth.call(env)
+    end
+
+    describe "on_complete handler" do
+      subject(:auth) { described_class.new(app, cache: cache) }
+      let(:cache) { instance_spy(described_class::RedisCache) }
+      let(:handler) {
+        handler = nil
+        allow(app).to receive(:call).and_return(app)
+        allow(app).to receive(:on_complete) { |&block| handler = block }
+
+        auth.call(env)
+
+        handler
+      }
+
+      it "removes value from cache when response is unsuccessful" do
+        expect(cache).to receive(:[]=).with("example.com", nil).exactly(2).times
+        handler.(status: 200)
+        handler.(status: 400)
+        handler.(status: 500)
+      end
+
+      it "retries the request after clearing the cache on a 403 response" do
+        expect(app).to receive(:call).with(env).ordered
+        expect(cache).to receive(:[]=).with("example.com", nil).ordered
+        expect(app).to receive(:call).with(env).ordered
+        handler.(status: 403)
+      end
+    end
+
+    class FakeApp
+      attr_accessor :response
+      def initialize(response)
+        @response = response
+      end
+      def call(request)
+        @request = request
+        self
+      end
+      def on_complete
+        @request[:body] = "response"
+        yield(response)
+      end
+    end
+
+    describe "multiple 403 errors" do
+      subject(:auth) { described_class.new(app, cache: cache, token_factory: -> (_) { "value" }) }
+      let(:cache) { instance_spy(described_class::RedisCache) }
+      let(:app) { FakeApp.new(body: "response", status: 403) }
+
+      it "doesn't retry forever" do
+        auth.call(env)
+      end
+
+      it "resets the body to original request body" do
+        expect(app).to receive(:call).with(hash_including(body: "request")).twice.and_call_original
+        auth.call(env.merge(body: "request"))
+      end
+    end
+  end
+
+  describe "#token_for" do
+    let(:cache) { instance_spy(described_class::RedisCache) }
+    subject(:auth) { described_class.new(:app, cache: cache) }
+
+    context "when cache is non-nil" do
+      before do
+        allow(cache).to receive(:[]).with("example.com").and_return("abc123")
+      end
+
+      it "returns value from cache" do
+        expect(auth.token_for("example.com")).to eq("abc123")
+      end
+
+      it "does not call @token_factory" do
+        expect(auth.token_factory).to_not receive(:call)
+        auth.token_for("example.com")
+      end
+    end
+
+    context "when cache is empty" do
+      before do
+        allow(cache).to receive(:[]).and_return(nil)
+        allow(auth.token_factory)
+          .to receive(:call).with("example.com").and_return("abc123")
+      end
+
+      it "calls @token_factory with passed host" do
+        expect(auth.token_for("example.com")).to eq("abc123")
+      end
+
+      it "stores the value in the cache" do
+        expect(cache).to receive(:[]=).with("example.com", "abc123")
+        auth.token_for("example.com")
+      end
+    end
+  end
+end