lexervariables 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 866f1bc83bd911c1870c91da77d7acd725f2961f
+  data.tar.gz: 55286b7635617c451c6c535488330e57a1cacdc6
+SHA512:
+  metadata.gz: d66dc4d6676cc0f4c66596970599ab3c6d63954078e1c5c44862288fbf07a0ef7a2c6ad1763a7b43cc4a73ff1d37194a798210279bd0d2316d0b9ef5e6665f51
+  data.tar.gz: c5c21c4c76e322a513b5ff3fa6b145cb939841e9bba7166ede0b114f6619ba109275713fe4ee6a9ee7eac8c29c4adc3df72441e96c7cb20b0568163f17d77d23

data/.gitignore

@@ -0,0 +1,38 @@
+*.gem
+*.rbc
+*.swp
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/test/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+.swp
+

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in lexervariables.gemspec
+gemspec

data/README.md

@@ -0,0 +1,25 @@
+# lexer-variables.gem
+
+Gem for loading variables (terms, geographies, authors, pages, oauths) to monitor
+
+Communicates with the [lexer-dashboard-app](http://github.com/lexerdev/lexer-dashboard-app) to lease:
+* Monitored Terms
+* Monitored Geo Regions
+* Monitored Authors
+* Monitored Pages
+* OAuths (with associations to above)
+
+This gem and the functionality held in the dashboard-app aims to retire the current implementation whereby variables and oauths are loaded from the Lexer-API thorugh the Lexer-API.gem.
+
+# Tests
+
+Run tests:
+    bundle exec rake test
+
+# IRB
+
+Need to have a tinker?
+    
+    irb -rubygems -I lib -r $PWD/lib/lexervariables.rb
+
+

data/Rakefile

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+require 'rake/testtask'
+
+Rake::TestTask.new do |task|
+  task.libs << %w(test lib)
+  task.pattern = 'test/*.rb'
+end
+
+task :default => :test

data/lexervariables.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "lexervariables/version"
+
+Gem::Specification.new do |s|
+  s.name          = "lexervariables"
+  s.version       = LexerVariables::VERSION
+  s.authors       = ["Aaron Wallis"]
+  s.email         = ["aaron.wallis@lexer.com.au"]
+  s.homepage      = "http://lexer.com.au"
+  s.summary       = "Gem for loading variables (terms, geographies, authors, pages, oauths) to monitor"
+  s.description   = "Gem for loading variables (terms, geographies, authors, pages, oauths) to monitor"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'faraday'
+  s.add_dependency 'multi_json'
+  s.add_dependency 'oj'
+
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'minitest-reporters'
+  s.add_development_dependency 'factory_girl'
+  s.add_development_dependency 'faker'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'webmock'
+end
+

data/lib/lexervariables.rb

@@ -0,0 +1,85 @@
+require 'oj'
+require 'multi_json'
+require 'lexervariables/error'
+require 'lexervariables/version'
+
+module LexerVariables
+  module_function
+
+  DEFAULT_ENDPOINT = 'https://lexer-dashboard/api/system/'
+  USER_AGENT       = 'Lexer Worker'
+  SECRET_TOKEN     = 'MLXTblicbwEVqyWXXrtz2DccoEuoqx9h5VFKZfBsP48QCOQ2hEcWvPDYoWwY4sQj'
+
+  def validate_provider(provider)
+    fail LexerVariables::UnknownProvider, "Unknown provider: #{provider}" unless [:facebook, :twitter, :instagram, :spinn3r, :yammer].include?(provider)
+    true
+  end
+
+  class Configuration
+    class << self
+      attr_accessor :endpoint
+      attr_accessor :api_key
+    end
+
+    @endpoint = DEFAULT_ENDPOINT
+    @api_key = SECRET_TOKEN
+    
+    def self.default_options
+      {'api_token' => self.api_key}
+    end
+  end
+
+  class LexerModel
+    attr_accessor :attrs
+    alias :to_hash :attrs
+
+    # Define methods that retrieve the value from an initialized instance variable Hash, using the attribute as a key
+    #
+    # @overload self.lazy_attr_reader(attr)
+    #   @param attr [Symbol]
+    # @overload self.lazy_attr_reader(attrs)
+    #   @param attrs [Array<Symbol>]
+    def self.lazy_attr_reader(*attrs)
+      attrs.each do |attribute|
+        class_eval do
+          define_method attribute do
+            @attrs[attribute.to_s]
+          end
+        end
+      end
+    end
+
+    # Initializes a new Base object
+    #
+    # @param attrs [Hash]
+    # @return [LexerModel]
+    def initialize(attrs={})
+      @attrs = attrs.dup
+    end
+
+    # Initializes a new Base object
+    #
+    # @param method [String, Symbol] Message to send to the object
+    def [](method)
+      self.__send__(method.to_sym)
+    rescue NoMethodError
+      nil
+    end
+
+  end
+end
+
+require 'lexervariables/api'
+require 'lexervariables/dashboard_object'
+require 'lexervariables/attribute_generator'
+require 'lexervariables/attribute_geo_region'
+require 'lexervariables/attribute_page'
+require 'lexervariables/attribute_user'
+require 'lexervariables/monitored_account'
+require 'lexervariables/monitored_object'
+require 'lexervariables/monitored_geo_region'
+require 'lexervariables/monitored_page'
+require 'lexervariables/monitored_term'
+require 'lexervariables/monitored_user'
+require 'lexervariables/monitored_url'
+require 'lexervariables/oauth'

data/lib/lexervariables/api.rb

@@ -0,0 +1,90 @@
+require 'faraday'
+require 'oj'
+require 'multi_json'
+
+module LexerVariables
+
+  class ParseJson < ::Faraday::Response::Middleware
+    def parse(body)
+      case body
+      when '', 'null'
+        nil
+      when 'true'
+        true
+      when 'false'
+        false
+      else
+        MultiJson.decode(body)
+      end
+    end
+
+    def on_complete(env)
+      if env[:status] >= 300
+        fail ::LexerVariables::RequestError, "API Request error #{env[:status]} : #{env[:url]} : #{MultiJson.encode(env[:request_headers])} #{env[:body]}"
+      elsif env[:status] == 204
+        env[:body] = nil
+      else
+        env[:body] = parse(env[:body])
+      end
+    end
+  end
+
+  def self.api_connection(options={})
+    default_options = {
+      :headers => {
+        :accept => 'application/json'
+      },
+      :ssl => {
+        :verify => false
+      }
+    }
+    @__api_connection ||= Faraday.new(default_options.merge(options)) do |builder|
+      builder.use(Faraday::Request::UrlEncoded) # convert request params as "www-form-urlencoded"
+      builder.use(LexerVariables::ParseJson) # Decode the response as JSON
+      builder.use(Faraday::Adapter::NetHttp)    # make http requests with Net::HTTP
+
+      # Enable if you want super noisy (but informative) logs
+      # builder.use Faraday::Response::Logger   # log the request to STDOUT
+    end
+  end
+
+  def self.reset_connection
+    @__api_connection = nil
+  end
+
+  module Request
+    module_function
+
+    # Perform an HTTP GET request
+    def get(path, params={}, options={})
+      request(:get, path, params, options)
+    end
+
+    # Perform an HTTP POST request
+    def self.post(path, params={}, options={})
+      request(:post, path, params, options)
+    end
+
+  private
+    # Perform an HTTP request
+    def self.request(method, path, params, options)
+      params.merge!(LexerVariables::Configuration.default_options)
+      path = "#{LexerVariables::Configuration.endpoint}#{path}"
+      response = LexerVariables::api_connection(options).run_request(method, nil, nil, nil) do |request|
+        case method.to_sym
+        when :delete, :get
+          request.url(path, params)
+        when :post, :put
+          request.path = path
+          request.body = params unless params.empty?
+          request.options.timeout = 20
+          request.options.open_timeout = 30
+        else
+          fail LexerVariables::RequestError, "Request method '#{method}' is unsupported"
+        end
+      end
+      response.body
+    end
+  end
+
+end

data/lib/lexervariables/attribute_generator.rb

@@ -0,0 +1,15 @@
+class LexerVariables::AttributeGenerator < LexerVariables::DashboardObject
+  ENDPOINT = "attribute_generators"
+
+  lazy_attr_reader :object, :attributes
+
+  def self.format_object(objects)
+    objects.collect do |object|
+      {
+      	'object' => object.fetch('monitored_object', {})['object'],
+      	'attributes' => object['attributes']
+      }
+    end
+  end
+end
+

data/lib/lexervariables/attribute_geo_region.rb

@@ -0,0 +1,7 @@
+class LexerVariables::AttributeGeoRegion < LexerVariables::AttributeGenerator
+  private
+  def self.object_type
+    'regions'
+  end
+end
+

data/lib/lexervariables/attribute_page.rb

@@ -0,0 +1,7 @@
+class LexerVariables::AttributePage < LexerVariables::AttributeGenerator
+  private
+  def self.object_type
+    'pages'
+  end
+end
+

data/lib/lexervariables/attribute_user.rb

@@ -0,0 +1,7 @@
+class LexerVariables::AttributeUser < LexerVariables::AttributeGenerator
+  private
+  def self.object_type
+    'users'
+  end
+end
+

data/lib/lexervariables/dashboard_object.rb

@@ -0,0 +1,34 @@
+class LexerVariables::DashboardObject < LexerVariables::LexerModel
+  def self.all(provider:, shards: 0)
+    LexerVariables.validate_provider(provider)
+ 
+    objects = LexerVariables::Request.get("#{self::ENDPOINT}/#{provider}/#{self.object_type}")
+    formatted_objects = format_object(objects)
+    shard_objects(objects:formatted_objects, shards:shards)
+  end
+
+  def self.format_object(objects)
+    objects
+  end
+  
+  def self.shard_objects(objects:, shards:)
+    return objects if shards == 0
+
+    # If we don't have enough objects to shard, every shard gets all the objects
+    return shards.times.collect{objects} if objects.size.to_f <= (shards * 2)
+
+    slice_size = (objects.size.to_f / shards).ceil
+    object_distribution = objects.each_slice(slice_size).collect{|i| i}
+    number_of_objects_to_shift = slice_size - object_distribution.last.size - 1
+    number_of_objects_to_shift.times do |i|
+      object_distribution.last << object_distribution[i].pop
+    end
+
+    object_distribution
+  end
+
+  def to_s
+    self.object
+  end
+end
+

data/lib/lexervariables/error.rb

@@ -0,0 +1,7 @@
+module LexerVariables
+  Error = Class.new(StandardError)
+
+  UnknownProvider = Class.new(Error)
+  RequestError    = Class.new(Error)
+  InvalidObject   = Class.new(Error)
+end

data/lib/lexervariables/monitored_account.rb

@@ -0,0 +1,85 @@
+require 'multi_json'
+
+class LexerVariables::MonitoredAccount < LexerVariables::LexerModel
+  attr_reader :key
+  attr_reader :secret
+  attr_reader :username
+  attr_reader :email
+  attr_reader :client_id
+  attr_reader :id
+  attr_reader :monitored_object
+
+  def initialize(data)
+
+    unless data.key?('access_token_key') && data.key?('access_token_secret')
+      fail LexerVariables::InvalidObject, "JSON OAuth returned (#{data}) was not usable due to missing fields."
+    end
+
+    @key              = data['access_token_key']
+    @secret           = data['access_token_secret']
+    @username         = data['username']
+    @email            = data['email']
+    @client_id        = data['client_id']
+    @monitored_object = data['monitored_object']
+    @id               = data['id']
+  end
+
+  def self.lease(provider)
+    self.lease_object(provider, nil)
+  end
+
+  def self.lease_object(provider, monitored_object)
+    LexerVariables.validate_provider(provider)
+
+    options = {}
+    if monitored_object
+      options['monitored_object'] = monitored_object
+    end
+
+    response = LexerVariables::Request.get("monitored_accounts/#{provider}/lease", options)
+    return nil if response == {}
+    LexerVariables::MonitoredAccount.new(response)
+  end
+
+  def self.all(provider)
+    LexerVariables.validate_provider(provider)
+
+    monitored_accounts = LexerVariables::Request.get("monitored_accounts/#{provider}")
+    return nil if monitored_accounts == []
+
+    response = []
+    monitored_accounts.each do |monitored_account|
+      response << LexerVariables::MonitoredAccount.new(monitored_account)
+    end
+    #Sort as lowest MonitoredAccount.id going to worker 0
+    response = response.sort_by{|account| account.id }
+
+    return response
+  end
+
+  def self.send_error(provider, error_message, id)
+    LexerVariables.validate_provider(provider)
+
+    options = { 
+      "provider" => provider,
+      "id" => id,
+      "error_message" => error_message
+    }
+
+    response = LexerVariables::Request.post('monitored_accounts/error', options)
+    if response.nil?
+      response = "Successfully posted email"
+    end
+    return response
+  end
+
+  def <=>(account)
+    if self.id < account.id
+      -1
+    elsif self.id > account.id
+      1
+    else
+      0
+    end
+  end
+end

data/lib/lexervariables/monitored_geo_region.rb

@@ -0,0 +1,7 @@
+class LexerVariables::MonitoredGeoRegion < LexerVariables::MonitoredObject
+  private
+  def self.object_type
+    'regions'
+  end
+end
+

data/lib/lexervariables/monitored_object.rb

@@ -0,0 +1,21 @@
+require 'multi_json'
+
+class LexerVariables::MonitoredObject < LexerVariables::DashboardObject
+  ENDPOINT = "monitored_objects"
+
+  lazy_attr_reader :object
+
+  def self.pop(provider:)
+    LexerVariables.validate_provider(provider)
+
+    response = LexerVariables::Request.get("#{ENDPOINT}/#{provider}/#{self.object_type}/pop")
+    self.new(response)
+  end
+
+  def self.format_object(objects)
+    objects.collect do |object|
+      object['object']
+    end
+  end
+end
+

data/lib/lexervariables/monitored_page.rb

@@ -0,0 +1,7 @@
+class LexerVariables::MonitoredPage < LexerVariables::MonitoredObject
+  private
+  def self.object_type
+    'pages'
+  end
+end
+

data/lib/lexervariables/monitored_term.rb

@@ -0,0 +1,7 @@
+class LexerVariables::MonitoredTerm < LexerVariables::MonitoredObject
+  private
+  def self.object_type
+    'terms'
+  end
+end
+

data/lib/lexervariables/monitored_url.rb

@@ -0,0 +1,7 @@
+class LexerVariables::MonitoredURL < LexerVariables::MonitoredObject
+  private
+  def self.object_type
+    'urls'
+  end
+end
+

data/lib/lexervariables/monitored_user.rb

@@ -0,0 +1,7 @@
+class LexerVariables::MonitoredUser < LexerVariables::MonitoredObject
+  private
+  def self.object_type
+    'users'
+  end
+end
+

data/lib/lexervariables/oauth.rb

@@ -0,0 +1,29 @@
+require 'multi_json'
+
+class LexerVariables::OAuth < LexerVariables::MonitoredObject
+  attr_reader :key
+  attr_reader :secret
+  attr_reader :username
+  attr_reader :email
+
+  def initialize(attrs)
+    super(attrs)
+    data = MultiJson::decode(object)
+
+    unless data.key?('access_token') && data.key?('access_token_secret')
+      fail LexerVariables::InvalidObject, "JSON OAuth returned (#{object}) was not usable due to missing fields."
+    end
+
+    @key = data['access_token']
+    @secret = data['access_token_secret']
+    @username = data['username']
+    @email = data['email']
+  end
+
+  private
+
+  def self.object_type
+    'oauths'
+  end
+end
+

data/lib/lexervariables/version.rb

@@ -0,0 +1,3 @@
+module LexerVariables
+  VERSION = "0.1.0"
+end

data/test/attribute_generator_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+describe LexerVariables::AttributeGenerator do
+
+  describe 'no objects to acquire' do
+    before do
+      stub_get("/api/system/attribute_generators/twitter/regions?api_token=#{LexerVariables::SECRET_TOKEN}").
+        to_return(body: MultiJson.dump('Not found'), status: 404) if $should_stub
+    end
+
+    it 'should fail for an unpopulated type' do
+      assert_raises LexerVariables::RequestError do
+        LexerVariables::AttributeGeoRegion.all(provider: :twitter)
+      end
+    end
+  end
+
+  describe '#all' do
+    let(:attribute_users) {
+      (1..10).collect { |x| test_attribute_user }
+    }
+
+    before do
+      stub_get("/api/system/attribute_generators/twitter/users?api_token=#{LexerVariables::SECRET_TOKEN}").
+        to_return(body: MultiJson.dump(attribute_users), status: 200) if $should_stub
+    end
+
+    it 'should get all attribute generator users for single provider' do
+      users = LexerVariables::AttributeUser.all(provider: :twitter)
+      users.must_be_instance_of(Array)
+      users.size.must_equal(10)
+    end
+
+    it 'should shard attribute generator users' do
+      users = LexerVariables::AttributeUser.all(provider: :twitter, shards: 4)
+      users.must_be_instance_of(Array)
+      users.size.must_equal(4)
+      users[0].must_be_instance_of(Array)
+      users[0].size.must_equal(2)
+      users[1].must_be_instance_of(Array)
+      users[1].size.must_equal(3)
+      users.flatten.size.must_equal(10)
+    end
+  end
+end

data/test/docker-launch-tests.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+# Script (*external*) to launch a Docker container and run tests
+docker run --rm -v $(pwd):/code -w /code phusion/passenger-ruby22 /code/test/docker-run-tests.sh

data/test/docker-run-tests.sh

@@ -0,0 +1,9 @@
+#!/bin/bash
+
+# Script to execute lexer-variables.gem tests *inside* a Docker container
+#
+# Expectations:
+# - lexer-variables.gem checkout is mounted at /code
+
+bundle install --standalone &&\
+  bundle exec rake test

data/test/factories/monitored_accounts.rb

@@ -0,0 +1,21 @@
+FactoryGirl.define do
+
+  factory :monitored_account, class:Hash do
+    id                  { Faker::Number.number(4).to_i }
+    provider            { "twitter"                    }
+    client_id           { Faker::Number.digit          }
+    username            { Faker::Internet.user_name    }
+    email               { Faker::Internet.email        }
+    access_token_key    { Faker::Internet.password(8)  }
+    access_token_secret { Faker::Internet.password(16) }
+    monitored_object    { Faker::Lorem::words(1)[0]    }
+    last_used           { DateTime.now.iso8601         }
+    expires             { DateTime.now.iso8601         }
+    created_time        { DateTime.now.iso8601         }
+    updated_time        { DateTime.now.iso8601         }
+    is_priority         { false                        }
+
+    initialize_with   { attributes }
+  end
+
+end

data/test/factories/monitored_terms.rb

@@ -0,0 +1,9 @@
+FactoryGirl.define do
+
+  factory :monitored_term, class:Hash do
+    object { Faker::Lorem::words(1)[0] }
+
+    initialize_with { attributes }
+  end
+
+end

data/test/factories/oauths.rb

@@ -0,0 +1,9 @@
+FactoryGirl.define do
+
+  factory :oauth, class:Hash do
+    object { MultiJson::encode({access_token: 'abcdef', access_token_secret:'ghi'}) }
+
+    initialize_with { attributes }
+  end
+
+end

data/test/lexer_variables_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+describe LexerVariables do
+  describe '#validate_provider' do
+    it 'should reject invalid network' do
+      assert_raises LexerVariables::UnknownProvider do
+        LexerVariables.validate_provider(:lexer)
+      end
+    end
+
+    it 'should accept valid networks' do
+      assert LexerVariables.validate_provider(:twitter)
+      assert LexerVariables.validate_provider(:spinn3r)
+      assert LexerVariables.validate_provider(:instagram)
+      assert LexerVariables.validate_provider(:facebook)
+      assert LexerVariables.validate_provider(:yammer)
+    end
+  end
+end

data/test/monitored_account_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+
+describe LexerVariables::MonitoredAccount do
+
+  describe 'no accounts to monitor' do
+    before do
+      stub_get("/api/system/monitored_accounts/twitter/lease?api_token=#{LexerVariables::SECRET_TOKEN}").
+        to_return(body: MultiJson.dump('Not found'), status: 404) if $should_stub
+    end
+
+    it 'fails' do
+      assert_raises LexerVariables::RequestError do
+        LexerVariables::MonitoredAccount.lease(:twitter)
+      end
+    end
+  end
+
+  describe '#all' do
+    let(:monitored_accounts) {[
+      FactoryGirl.build(:monitored_account),
+      FactoryGirl.build(:monitored_account),
+      FactoryGirl.build(:monitored_account),
+      FactoryGirl.build(:monitored_account),
+      FactoryGirl.build(:monitored_account)
+    ]}
+
+    before do
+      stub_get("/api/system/monitored_accounts/twitter?api_token=#{LexerVariables::SECRET_TOKEN}").
+        to_return(body: MultiJson.dump(monitored_accounts)) if $should_stub
+
+      stub_get("/api/system/monitored_accounts/facebook?api_token=#{LexerVariables::SECRET_TOKEN}").
+        to_return(body: MultiJson.dump([])) if $should_stub
+    end
+
+    it 'should get all monitored accounts for single provider' do
+      accounts = LexerVariables::MonitoredAccount.all(:twitter)
+      accounts.must_be_instance_of(Array)
+      accounts.size.must_equal(5)
+    end
+
+    it 'should return nil for provider with no accounts' do
+      accounts = LexerVariables::MonitoredAccount.all(:facebook)
+      accounts.must_be_instance_of(NilClass)
+    end
+
+    it 'should return monitored accounts in sorted order' do
+      accounts = LexerVariables::MonitoredAccount.all(:twitter)
+      accounts.must_be_instance_of(Array)
+      accounts.size.must_equal(5)
+      last_id = -1
+      sorted  = true
+      accounts.each do |account|
+        sorted  &= account.id > last_id
+        last_id  = account.id if sorted
+      end
+      assert(sorted, 'monitored_accounts are not sorted by .id')
+    end
+  end
+
+  describe 'twitter' do
+    let(:monitored_account) {
+      FactoryGirl.build(:monitored_account)
+    }
+
+    describe 'get accounts to monitor' do
+      before do
+        stub_get("/api/system/monitored_accounts/twitter/lease?api_token=#{LexerVariables::SECRET_TOKEN}").
+          to_return(body: MultiJson.dump(monitored_account)) if $should_stub
+      end
+
+      it 'leases a single account' do
+        account = LexerVariables::MonitoredAccount.lease(:twitter)
+        account.must_be_instance_of(LexerVariables::MonitoredAccount)
+        account.monitored_object.must_equal(monitored_account[:monitored_object])
+        account.key.must_equal(monitored_account[:access_token_key])
+        account.secret.must_equal(monitored_account[:access_token_secret])
+        account.client_id.must_equal(monitored_account[:client_id])
+      end
+    end
+  end
+
+  describe 'facebook' do
+    let(:monitored_account) {
+      FactoryGirl.build(:monitored_account)
+    }
+
+    let(:facebook_page_id) {
+      Faker::Internet.password(8)
+    }
+
+    describe 'get accounts to monitor' do
+      before do
+        stub_get("/api/system/monitored_accounts/facebook/lease?api_token=#{LexerVariables::SECRET_TOKEN}&monitored_object=#{facebook_page_id}").
+          to_return(body: MultiJson.dump(monitored_account)) if $should_stub
+      end
+
+      it 'leases a single account' do
+        account = LexerVariables::MonitoredAccount.lease_object(:facebook, facebook_page_id)
+        account.must_be_instance_of(LexerVariables::MonitoredAccount)
+        account.monitored_object.must_equal(monitored_account[:monitored_object])
+        account.key.must_equal(monitored_account[:access_token_key])
+        account.secret.must_equal(monitored_account[:access_token_secret])
+      end
+    end
+  end
+end

data/test/monitored_object_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+describe LexerVariables::MonitoredObject do
+
+  describe 'no objects to acquire' do
+    before do
+      stub_get("/api/system/monitored_objects/twitter/regions/pop?api_token=#{LexerVariables::SECRET_TOKEN}").
+        to_return(body: MultiJson.dump('Not found'), status: 404) if $should_stub
+    end
+
+    it 'should fail for an unpopulated type' do
+      assert_raises LexerVariables::RequestError do
+        LexerVariables::MonitoredGeoRegion.pop(provider: :twitter)
+      end
+    end
+  end
+
+  describe '#all' do
+    let(:monitored_terms) {
+      (1..10).collect { |x| FactoryGirl.build(:monitored_term, object: x.to_s) }
+    }
+
+    before do
+      stub_get("/api/system/monitored_objects/twitter/terms?api_token=#{LexerVariables::SECRET_TOKEN}").
+        to_return(body: MultiJson.dump(monitored_terms), status: 200) if $should_stub
+    end
+
+    it 'should get all monitored terms for single provider' do
+      terms = LexerVariables::MonitoredTerm.all(provider: :twitter)
+      terms.must_be_instance_of(Array)
+      terms.size.must_equal(10)
+    end
+
+    it 'should shard monitored terms' do
+      terms = LexerVariables::MonitoredTerm.all(provider: :twitter, shards: 4)
+      terms.must_be_instance_of(Array)
+      terms.size.must_equal(4)
+      terms[0].must_be_instance_of(Array)
+      terms[0].size.must_equal(2)
+      terms[1].must_be_instance_of(Array)
+      terms[1].size.must_equal(3)
+      terms.flatten.size.must_equal(10)
+    end
+
+  end
+
+  describe '#pop' do
+    let(:monitored_term) { |x| FactoryGirl.build(:monitored_term) }
+
+    before do
+      stub_get("/api/system/monitored_objects/twitter/terms/pop?api_token=#{LexerVariables::SECRET_TOKEN}").
+        to_return(body: MultiJson.dump(monitored_term), status: 200) if $should_stub
+      stub_get("/api/system/monitored_objects/twitter/regions/pop?api_token=#{LexerVariables::SECRET_TOKEN}").
+        to_return(body: '{"error":"404 Not Found"}', status: 404) if $should_stub
+    end
+
+    it 'should acquire a term' do
+      term1 = LexerVariables::MonitoredTerm.pop(provider: :twitter)
+      term1.to_s.must_equal(monitored_term[:object])
+    end
+  end
+end

data/test/oauth_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+describe LexerVariables::OAuth do
+
+  describe '#pop' do
+    let(:oauth) { |x| FactoryGirl.build(:oauth) }
+
+    before do
+      stub_get("/api/system/monitored_objects/twitter/oauths/pop?api_token=#{LexerVariables::SECRET_TOKEN}").
+        to_return(body: MultiJson.dump(oauth), status: 200) if $should_stub
+    end
+
+    it 'should acquire an OAuth' do
+      oauth = LexerVariables::OAuth.pop(provider: :twitter)
+      oauth.key.must_equal('abcdef')
+      oauth.secret.must_equal('ghi')
+    end
+
+  end
+
+
+end

data/test/test_helper.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+require 'minitest/autorun'
+require 'minitest/reporters'
+require 'minitest/spec'
+require 'webmock/minitest'
+require 'faker'
+require 'factory_girl'
+
+MiniTest::Reporters.use! [Minitest::Reporters::SpecReporter.new, MiniTest::Reporters::JUnitReporter.new]
+require File.join(File.dirname(__FILE__), '..', 'lib', 'lexervariables')
+FactoryGirl.find_definitions
+
+$should_stub = true
+if $should_stub
+  WebMock.disable_net_connect!
+else
+  WebMock.allow_net_connect!
+end
+
+def request_path(path)
+  "https://lexer-dashboard#{path}"
+end
+
+def stub_get(path)
+  WebMock::API.stub_http_request(:get, request_path(path))
+end
+
+# As the hash requires a key called 'attributes', this breaks factory call as when you call
+# ```initialise_with { attributes }``` in FactoryGirl, it becomes infinitely recursive.
+def test_attribute_user
+  {
+    monitored_object: {
+      object: Faker::Number.number(10)
+    },
+    attributes: ['io.company.' + Faker::Lorem::words(1)[0]] * 3
+  }
+end

metadata

@@ -0,0 +1,204 @@
+--- !ruby/object:Gem::Specification
+name: lexervariables
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Aaron Wallis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Gem for loading variables (terms, geographies, authors, pages, oauths)
+  to monitor
+email:
+- aaron.wallis@lexer.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- lexervariables.gemspec
+- lib/lexervariables.rb
+- lib/lexervariables/api.rb
+- lib/lexervariables/attribute_generator.rb
+- lib/lexervariables/attribute_geo_region.rb
+- lib/lexervariables/attribute_page.rb
+- lib/lexervariables/attribute_user.rb
+- lib/lexervariables/dashboard_object.rb
+- lib/lexervariables/error.rb
+- lib/lexervariables/monitored_account.rb
+- lib/lexervariables/monitored_geo_region.rb
+- lib/lexervariables/monitored_object.rb
+- lib/lexervariables/monitored_page.rb
+- lib/lexervariables/monitored_term.rb
+- lib/lexervariables/monitored_url.rb
+- lib/lexervariables/monitored_user.rb
+- lib/lexervariables/oauth.rb
+- lib/lexervariables/version.rb
+- test/attribute_generator_test.rb
+- test/docker-launch-tests.sh
+- test/docker-run-tests.sh
+- test/factories/monitored_accounts.rb
+- test/factories/monitored_terms.rb
+- test/factories/oauths.rb
+- test/lexer_variables_test.rb
+- test/monitored_account_test.rb
+- test/monitored_object_test.rb
+- test/oauth_test.rb
+- test/test_helper.rb
+homepage: http://lexer.com.au
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Gem for loading variables (terms, geographies, authors, pages, oauths) to
+  monitor
+test_files: []