task_helper 0.0.1

data/lib/task_helper/version.rb

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

data/lib/task_helper.rb

@@ -0,0 +1,15 @@
+require 'httparty'
+
+require 'task_helper/version'
+require 'task_helper/api/call'
+require 'task_helper/api/cache'
+require 'task_helper/api'
+require 'task_helper/base'
+require 'task_helper/record'
+require 'task_helper/field'
+require 'task_helper/form'
+require 'task_helper/database'
+
+module TaskHelper
+  # Your code goes here...
+end

data/lib/tasks/spec_setup.rake

@@ -0,0 +1,41 @@
+namespace :spec do
+  task :setup, [:api_key] do |t, args|
+    TaskHelper::API.rest_api_key = args[:api_key]
+
+    File.open('spec/support/fixtures/databases.json', 'w') do |f|
+      f.write(JSON.pretty_generate(TaskHelper::API.get(route: 'apps.json')))
+    end
+
+    TaskHelper::API.get(route: 'apps.json')['databases'].each do |db|
+      db_dir = "spec/support/fixtures/databases/#{db['id']}"
+      db_route = "apps/#{db['id']}"
+      forms_route = "#{db_route}/entities"
+      FileUtils.mkdir_p(db_dir)
+      File.open("#{db_dir}/forms.json", 'w') do |f|
+        f.write(JSON.pretty_generate(TaskHelper::API.get(route: "#{forms_route}.json")))
+      end
+
+      TaskHelper::API.get(route: "apps/#{db['id']}/entities.json")['forms'].each do |form|
+        form_dir = "#{db_dir}/forms/#{form['id']}"
+        fields_route = "#{forms_route}/#{form['id']}/properties"
+        FileUtils.mkdir_p(form_dir)
+        File.open("#{form_dir}/fields.json", 'w') do |f|
+          f.write(JSON.pretty_generate(TaskHelper::API.get(route: "#{fields_route}.json")))
+        end
+
+        if TaskHelper::API.get(route: "#{fields_route}.json")['fields'].any?
+          records_route = "#{db_route}/dtypes/entity/#{form['id']}"
+          records_dir = "#{form_dir}/records"
+          FileUtils.mkdir_p(records_dir)
+          page_count = db['dtypes_count'].to_i / form['per_page'].to_i + 1
+          (1..page_count).each do |page|
+            File.open("#{records_dir}/#{page}.json", 'w') do |f|
+              f.write(JSON.pretty_generate(TaskHelper::API
+                .get(route: "#{records_route}.json", params: { page: page })))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/task_helper/api/cache_spec.rb

@@ -0,0 +1,73 @@
+describe TaskHelper::API::Cache do
+  before(:all) { TaskHelper::API.rest_api_key = 'foobar' }
+  after(:all) { TaskHelper::API.rest_api_key = nil }
+
+  subject { described_class.new(limit: 2) }
+
+  describe '#get' do
+    context 'call already cached' do
+      it 'should query the existing call' do
+        call1 = TaskHelper::API::Call.new(route: 'hello')
+        call2 = TaskHelper::API::Call.new(route: 'hello')
+        expect(TaskHelper::API::Call).to receive(:new).with(route: 'hello')
+          .twice.and_return(call1, call2)
+        expect(call1).to receive(:run).twice
+        subject.get(route: 'hello')
+        subject.get(route: 'hello')
+      end
+    end
+
+    context 'call not yet cached' do
+      it 'should query a new call' do
+        call1 = TaskHelper::API::Call.new(route: 'hello')
+        call2 = TaskHelper::API::Call.new(route: 'goodbye')
+        expect(call1).to receive(:run).once
+        expect(call2).to receive(:run).once
+        expect(TaskHelper::API::Call).to receive(:new).once.ordered
+          .with(route: 'hello').and_return(call1)
+        expect(TaskHelper::API::Call).to receive(:new).once.ordered
+          .with(route: 'goodbye').and_return(call2)
+        subject.get(route: 'hello')
+        subject.get(route: 'goodbye')
+      end
+
+      it 'should cache the new call' do
+        call1 = TaskHelper::API::Call.new(route: 'hello')
+        call2 = TaskHelper::API::Call.new(route: 'goodbye')
+        call3 = TaskHelper::API::Call.new(route: 'goodbye')
+        expect(call1).to receive(:run).once
+        expect(call2).to receive(:run).twice
+        expect(TaskHelper::API::Call).to receive(:new).once.ordered
+          .with(route: 'hello').and_return(call1)
+        expect(TaskHelper::API::Call).to receive(:new).twice.ordered
+          .with(route: 'goodbye').and_return(call2, call3)
+        subject.get(route: 'hello')
+        subject.get(route: 'goodbye')
+        subject.get(route: 'goodbye')
+      end
+
+      it 'should remove older calls if the limit is reached' do
+        call1 = TaskHelper::API::Call.new(route: 'hello')
+        call2 = TaskHelper::API::Call.new(route: 'goodbye')
+        call3 = TaskHelper::API::Call.new(route: 'foobar')
+        call4 = TaskHelper::API::Call.new(route: 'hello')
+        expect(call1).to receive(:run).once
+        expect(call2).to receive(:run).once
+        expect(call3).to receive(:run).once
+        expect(call4).to receive(:run).once
+        expect(TaskHelper::API::Call).to receive(:new).once.ordered
+          .with(route: 'hello').and_return(call1)
+        expect(TaskHelper::API::Call).to receive(:new).once.ordered
+          .with(route: 'goodbye').and_return(call2)
+        expect(TaskHelper::API::Call).to receive(:new).once.ordered
+          .with(route: 'foobar').and_return(call3)
+        expect(TaskHelper::API::Call).to receive(:new).once.ordered
+          .with(route: 'hello').and_return(call4)
+        subject.get(route: 'hello')
+        subject.get(route: 'goodbye')
+        subject.get(route: 'foobar')
+        subject.get(route: 'hello')
+      end
+    end
+  end
+end

data/spec/lib/task_helper/api/call_spec.rb

@@ -0,0 +1,136 @@
+describe TaskHelper::API::Call do
+  let(:key) { { rest_api_key: 'foobar' } }
+  let(:response) { double(parsed_response: [{ 'a' => 1 }]) }
+
+  it 'should define a reader for time' do
+    t = Time.now
+    args = { route: 'hello', params: key, time: t }
+    expect(described_class.new(args).time).to eq(t)
+  end
+
+  describe '.new' do
+    context 'given an api key' do
+      subject { described_class.new(route: 'hello', params: key) }
+
+      it 'should not raise a missing key error' do
+        expect { subject }.not_to raise_exception
+      end
+
+      it 'should replace the default key' do
+        TaskHelper::API.rest_api_key = 'hello'
+        expect(HTTParty).to receive(:get)
+          .with(anything, query: key).and_return(response)
+        subject.run
+        TaskHelper::API.rest_api_key = nil
+      end
+    end
+
+    context 'without an api key' do
+      subject { described_class.new(route: 'hello') }
+
+      it 'should attempt to use the default' do
+        TaskHelper::API.rest_api_key = 'hello'
+        expect(HTTParty).to receive(:get)
+          .with(anything, query: { rest_api_key: 'hello' }).and_return(response)
+        subject.run
+        TaskHelper::API.rest_api_key = nil
+      end
+
+      it 'should raise an exception if no default is set' do
+        expect { subject }.to raise_exception(TaskHelper::API::Call::MissingAPIKey)
+      end
+    end
+  end
+
+  describe '#run' do
+    before(:all) { TaskHelper::API.rest_api_key = 'foobar' }
+    after(:all) { TaskHelper::API.rest_api_key = nil }
+
+    subject { described_class.new(route: 'hello') }
+
+    it 'should reset the time' do
+      expect { subject.run }.to change { subject.time }
+    end
+
+    it 'should make a request to the given route at mytaskhelper.com' do
+      expect(HTTParty).to receive(:get)
+        .with('https://mytaskhelper.com/hello', query: { rest_api_key: 'foobar' })
+        .and_return(response)
+      subject.run
+    end
+
+    context 'call has expired' do
+      it 'should resend the request' do
+        params = { route: 'hello', timeout: 0 }
+        call = described_class.new(params)
+        expect(HTTParty).to receive(:get).twice.and_return(response)
+        call.run
+        call.run
+      end
+    end
+
+    context 'call has not expired' do
+      context 'request has been cached' do
+        it 'should return the cached response' do
+          expect(HTTParty).to receive(:get).once.and_return(response)
+          result = subject.run
+          expect(subject.run).to eq(result)
+        end
+      end
+
+      context 'request has not been chached' do
+        it 'should retrieve the response' do
+          expect(HTTParty).to receive(:get).once.and_return(response)
+          expect(subject.run).to eq(response.parsed_response)
+        end
+      end
+    end
+  end
+
+  describe '#expired?' do
+    before(:all) { TaskHelper::API.rest_api_key = 'foobar' }
+    after(:all) { TaskHelper::API.rest_api_key = nil }
+
+    context 'request timed out' do
+      it 'shoud return false' do
+        args = { route: 'hello', timeout: 0, time: Time.now - 5 }
+        expect(described_class.new(args).expired?).to be(true)
+      end
+    end
+
+    context 'request not timed out' do
+      it 'shoud return false' do
+        args = { route: 'hello', timeout: 100, time: Time.now - 5 }
+        expect(described_class.new(args).expired?).to be(false)
+      end
+    end
+  end
+
+  describe '#==' do
+    before(:all) { TaskHelper::API.rest_api_key = 'foobar' }
+    after(:all) { TaskHelper::API.rest_api_key = nil }
+
+    subject { described_class.new(route: 'hello', params: { a: 1 }) }
+
+    context 'route does not match' do
+      it 'should return false' do
+        expect(subject == described_class.new(route: 'hi'))
+          .to be(false)
+      end
+    end
+
+    context 'args do not match' do
+      it 'should return false' do
+        expect(subject == described_class.new(route: 'hello', params: { b: 2 }))
+          .to be(false)
+      end
+    end
+
+    context 'route and args match' do
+      it 'should return true' do
+        expect(subject == described_class.new(route: 'hello', params: { a: 1 }))
+          .to be(true)
+      end
+    end
+  end
+end

data/spec/lib/task_helper/api_spec.rb

@@ -0,0 +1,45 @@
+describe TaskHelper::API do
+  subject { TaskHelper::API }
+
+  it 'should define a singleton accessor for "rest_api_key"' do
+    expect(subject.rest_api_key).to eq(nil)
+    expect { subject.rest_api_key = 'foobar' }
+      .to change { subject.rest_api_key }.from(nil).to('foobar')
+  end
+
+  describe '.get' do
+    before(:all) { TaskHelper::API.rest_api_key = 'foobar' }
+    after(:all) { TaskHelper::API.rest_api_key = nil }
+
+    it 'should forward to the cache' do
+      expect_any_instance_of(TaskHelper::API::Cache).to receive(:get)
+        .with(route: 'hello')
+      subject.get(route: 'hello')
+    end
+  end
+
+  describe '.set_cache' do
+    before(:all) { TaskHelper::API.rest_api_key = 'foobar' }
+    after(:all) { TaskHelper::API.rest_api_key = nil }
+
+    it 'should reset the cache to a new instance with the given arguments' do
+      cache = TaskHelper::API::Cache.new(limit: 2)
+      expect(TaskHelper::API::Cache).to receive(:new).with(limit: 2)
+        .and_return(cache)
+      subject.set_cache(limit: 2)
+      expect(cache).to receive(:get).with(route: 'hello')
+      subject.get(route: 'hello')
+    end
+  end
+
+  describe '.extended' do
+    before(:all) { TaskHelper::API.rest_api_key = 'foobar' }
+    after(:all) { TaskHelper::API.rest_api_key = nil }
+
+    it 'should set the cache for the class' do
+      test = Class.new
+      expect(test).to receive(:set_cache)
+      test.extend(subject)
+    end
+  end
+end

data/spec/lib/task_helper/database_spec.rb

@@ -0,0 +1,91 @@
+describe TaskHelper::Database do
+  before(:all) { TaskHelper::API.rest_api_key = 'foobar' }
+  after(:all) { TaskHelper::API.rest_api_key = nil }
+
+  describe '.all' do
+    it 'should return an array of databases' do
+      expect(described_class.all.first).to be_a(described_class)
+    end
+
+    it 'should return databases corresponding to the API response' do
+      expect(described_class.all.map(&:to_h).to_json)
+        .to eq(FixtureParser.databases.to_json)
+    end
+  end
+
+  describe '.find_by' do
+    it 'should return the corresponding database if found' do
+      db = described_class.all.sample
+      expect(described_class.find_by(name: db.name)).to eq(db)
+    end
+
+    it 'should return nil if no database found' do
+      expect(described_class.find_by(name: 'odiasoutee')).to be_nil
+    end
+  end
+
+  describe '.find_by_name' do
+    it 'should return the corresponding database if found' do
+      db = described_class.all.sample
+      expect(described_class.find_by_name(db.name)).to eq(db)
+    end
+
+    it 'should return nil if no database found' do
+      expect(described_class.find_by_name('odiasoutee')).to be_nil
+    end
+  end
+
+  describe '.find' do
+    it 'should return the corresponding database if found' do
+      db = described_class.all.sample
+      expect(described_class.find(db.id)).to eq(db)
+    end
+
+    it 'should retrun nil if the database is not found' do
+      expect(described_class.find('hasdof')).to be_nil
+    end
+  end
+
+  describe 'data members' do
+    described_class.data_members.each do |m|
+      describe "##{m}" do
+        it "should return the value of #{m}" do
+          db = described_class.new(FixtureParser.databases.sample)
+          data = FixtureParser.pretty(:database, db.id)
+          expect(db.public_send(m)).to eq(data.send(m))
+        end
+      end
+    end
+  end
+
+  describe '#created_at' do
+    it 'should return the parsed time of created_at' do
+      db = described_class.all.sample
+      db_hash = FixtureParser.database(db.id)
+      expect(db.created_at).to eq(Time.parse(db_hash['created_at']))
+    end
+  end
+
+  describe '#updated_at' do
+    it 'should return the parsed time of updated_at' do
+      db = described_class.all.sample
+      db_hash = FixtureParser.database(db.id)
+      expect(db.updated_at).to eq(Time.parse(db_hash['updated_at']))
+    end
+  end
+
+  describe '#forms' do
+    it 'should return all forms associated with the database' do
+      db = described_class.all.sample
+      forms = FixtureParser.pretty(:forms, db.id)
+      expect(db.forms.all? { |f| f.kind_of?(TaskHelper::Form) }).to be(true)
+      expect(db.forms).to match_array(forms)
+    end
+
+    it "should pre-load the form's database attribute" do
+      db = described_class.all.sample
+      expect(described_class).not_to receive(:find)
+      db.forms.first.database
+    end
+  end
+end

data/spec/lib/task_helper/field_spec.rb

@@ -0,0 +1,50 @@
+describe TaskHelper::Field do
+  before(:all) { TaskHelper::API.rest_api_key = 'foobar' }
+  after(:all) { TaskHelper::API.rest_api_key = nil }
+
+  describe '.new' do
+    it 'should pass all params except form to super' do
+      form = TaskHelper::Form.all.first
+      field = described_class.new(name: 'foobar', form: form,
+        'entity_id' => form.id)
+      expect(field.name).to eq('foobar')
+      expect(field.entity_id).to eq(form.id)
+    end
+
+    context 'given an optional form' do
+      it 'should store the form' do
+        form = TaskHelper::Form.all.first
+        expect(TaskHelper::Form).not_to receive(:find)
+        field = described_class.new(form: form)
+        expect(field.form).to eq(form)
+      end
+    end
+
+    context 'without optional form' do
+      it 'should fetch the form when needed' do
+        expect(TaskHelper::Form).to receive(:find).at_least(1)
+        described_class.new.form
+      end
+    end
+  end
+
+  describe '#form' do
+    it 'should return the associated form' do
+      field = described_class.new(FixtureParser.fields.sample)
+      expect(field.form).to be_a(TaskHelper::Form)
+      expect(field.form.id).to eq(field.entity_id)
+    end
+  end
+
+  describe 'data members' do
+    described_class.data_members.each do |m|
+      describe "##{m}" do
+        it "should return the value of #{m}" do
+          field = described_class.new(FixtureParser.fields.sample)
+          data = FixtureParser.pretty(:field, field.id, field.entity_id)
+          expect(field.public_send(m)).to eq(data.send(m))
+        end
+      end
+    end
+  end
+end

data/spec/lib/task_helper/form_spec.rb

@@ -0,0 +1,141 @@
+describe TaskHelper::Form do
+  before(:all) { TaskHelper::API.rest_api_key = 'foobar' }
+  after(:all) { TaskHelper::API.rest_api_key = nil }
+
+  describe '.new' do
+    it 'should pass all params except database to super' do
+      db = TaskHelper::Database.all.sample
+      form = described_class.new(app_id: db.id, database: db,
+        'name' => 'foobar')
+      expect(form.app_id).to eq(db.id)
+      expect(form.name).to eq('foobar')
+    end
+
+    context 'given an optional database' do
+      it 'should store the database' do
+        db = TaskHelper::Database.all.sample
+        expect(TaskHelper::Database).not_to receive(:find)
+        form = described_class.new(database: db)
+        expect(form.database).to eq(db)
+      end
+    end
+
+    context 'without optional database' do
+      it 'should fetch the database when needed' do
+        expect(TaskHelper::Database).to receive(:find)
+        described_class.new.database
+      end
+    end
+  end
+
+  describe '.all' do
+    it 'should return all forms for all databases' do
+      forms = FixtureParser.pretty(:forms)
+      expect(described_class.all.all? { |f| f.kind_of?(described_class) })
+        .to be(true)
+      expect(described_class.all).to match_array(forms)
+    end
+
+    it 'should use a Lazy Enumerator' do
+      expect(described_class.all).to be_an(Enumerator::Lazy)
+    end
+  end
+
+  describe '.find' do
+    it 'should return the corresponding form if found' do
+      form = FixtureParser.pretty(:forms).sample
+      result = described_class.find(database: form.app_id, form: form.id)
+      expect(result).to be_a(described_class)
+      expect(result).to eq(form)
+    end
+
+    it 'should retrun nil if the form is not found' do
+      expect(described_class.find(database: 'hasdof', form: 'hasdof'))
+        .to be_nil
+    end
+  end
+
+  describe '.find_by' do
+    it 'should return the corresponding form if found' do
+      form = FixtureParser.pretty(:forms).sample
+      db = FixtureParser.pretty(:database, form.app_id)
+      result = described_class.find_by(database_name: db.name,
+                                       form_name: form.name)
+      expect(result).to be_a(described_class)
+      expect(result).to eq(form)
+    end
+
+    it 'should retrun nil if the form is not found' do
+      expect(described_class.find_by(database_name: 'hasdof',
+        form_name: 'hasdof')).to be_nil
+    end
+  end
+
+  describe '#database' do
+    it 'should return the database associated with the form' do
+      form = described_class.new(FixtureParser.forms.sample)
+      expect(form.database).to be_a(TaskHelper::Database)
+      expect(form.database.id).to eq(form.app_id)
+    end
+  end
+
+  describe '#fields' do
+    it 'should return the associated fields' do
+      form = described_class.new(FixtureParser.forms.sample)
+      expect(form.fields.all? { |f| f.kind_of?(TaskHelper::Field) }).to be(true)
+      expect(form.fields.all? { |f| f.entity_id == form.id }).to be(true)
+    end
+
+    it "should pre-load the fields' form attribute" do
+      form = described_class.all.first
+      expect(described_class).not_to receive(:find)
+      form.fields.first.form
+    end
+  end
+
+  describe '#records' do
+    context 'form has no fields' do
+      it 'should return nil' do
+        if form = described_class.all.find { |f| f.fields.none? }
+          expect(form.records).to be(nil)
+        else
+          expect(TaskHelper::Field).to receive(:get).and_return('fields' => [])
+          expect(described_class.new.records).to be(nil)
+        end
+      end
+    end
+
+    context 'form has at least one field' do
+      it 'should return a lazy enumerator containing the associated records' do
+        if form = described_class.all.find { |f| f.fields.any? }
+          expect(form.records).to be_a(Enumerator::Lazy)
+          expect(form.records.first).to be_a(TaskHelper::Record)
+          expect(form.records.first.entity_id).to eq(form.id)
+        else
+          raise 'No forms with fields found'.inspect
+        end
+      end
+
+      it "should pre-load the records' form attribute" do
+        if form = described_class.all.find { |f| f.fields.any? }
+          expect(described_class).not_to receive(:find)
+          form.records.first.form
+        else
+          raise 'No forms with fields found'.inspect
+        end
+      end
+    end
+  end
+
+  describe 'data members' do
+    described_class.data_members.each do |m|
+      describe "##{m}" do
+        it "should return the value of #{m}" do
+          form = described_class.new(FixtureParser.forms.sample)
+          data = FixtureParser.pretty(:form, form.id, form.database.id)
+          expect(form.public_send(m)).to eq(data.send(m))
+        end
+      end
+    end
+  end
+end

data/spec/lib/task_helper/record_spec.rb

@@ -0,0 +1,73 @@
+describe TaskHelper::Record do
+  before(:all) { TaskHelper::API.rest_api_key = 'foobar' }
+  after(:all) { TaskHelper::API.rest_api_key = nil }
+
+  let(:form) { TaskHelper::Form.all.find(:form_with_fields_needed) { |f| f.fields.any? } }
+  let(:data) { FixtureParser.pretty(:records, form.id, form.app_id).sample }
+  subject { described_class.new(data.to_h) }
+
+  describe '.new' do
+    it 'should pass all params except form to super' do
+      form = TaskHelper::Form.all.first
+      record = described_class.new(app_id: form.app_id, form: form,
+        'entity_id' => form.id)
+      expect(record.app_id).to eq(form.app_id)
+      expect(record.entity_id).to eq(form.id)
+    end
+
+    context 'given an optional form' do
+      it 'should store the form' do
+        form = TaskHelper::Form.all.first
+        expect(TaskHelper::Form).not_to receive(:find)
+        record = described_class.new(form: form)
+        expect(record.form).to eq(form)
+      end
+    end
+
+    context 'without optional form' do
+      it 'should fetch the form when needed' do
+        expect(TaskHelper::Form).to receive(:find).at_least(1)
+        described_class.new.form
+      end
+    end
+  end
+
+  describe '#form' do
+    it 'should return the associated form' do
+      expect(subject.form).to eq(form)
+    end
+  end
+
+  describe '#fields' do
+    it 'should return the fields of the associated form' do
+      expect(subject.fields).to match_array(form.fields)
+    end
+  end
+
+  describe '#[]' do
+    it 'should return the value of the field with the given name' do
+      field = form.fields.sample
+      expect(subject[field.name]).to eq(subject.values[field.id])
+    end
+  end
+
+  describe '#pretty_values' do
+    it 'should return the values hashed by field name' do
+      result = subject.values.each_with_object({}) do |(k, v), r|
+        field = form.fields.find { |f| f.id == k }
+        r[field.name] = v
+      end
+      expect(subject.pretty_values).to eq(result)
+    end
+  end
+
+  describe 'data members' do
+    described_class.data_members.each do |m|
+      describe "##{m}" do
+        it "should return the value of #{m}" do
+          expect(subject.public_send(m)).to eq(data.public_send(m))
+        end
+      end
+    end
+  end
+end

data/spec/lib/task_helper/version_spec.rb

@@ -0,0 +1,5 @@
+describe TaskHelper do
+  it 'should define its version' do
+    expect(TaskHelper::VERSION).not_to be_nil
+  end
+end