jamnagar 1.3.8

data/spec/contributor_store_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Jamnagar::Storage::SourceStore do
+  context 'Finding Contributors' do
+    before do
+      @adapter = double(Jamnagar::Adapters::MongoAdapter, :store => 123)
+      @sut = Jamnagar::Storage::ContributorStore.new(@adapter)
+    end
+    context 'When the contributor exists' do
+      before do
+        @item = {"_id" => 2}
+        @existing = {"_id" => 123, "contributions" => [1]}
+        allow(@adapter).to receive(:find_first).and_return(@existing)
+      end
+      it 'should return the contributor' do
+        expect(@sut.find_contributor({}, {"id" => 123})).to eq(@existing)
+      end
+      it 'should update contributions on the contributor' do
+        expect(@adapter).to receive(:update).with({"_id" => 123}, {"$set" => {"contributions" => [1,2]}, "$inc" => {"contributions_count" => 1}})
+        @sut.find_contributor(@item, {"id" => 123})
+      end
+    end
+    context 'When the contributor does not exist' do
+      it 'should insert and return the record' do
+        allow(@adapter).to receive(:find_first).and_return(nil)
+        expect(@adapter).to receive(:store).with(123, {"id" => 123, "_id" => 123, "contributions" => [42], "contributions_count" => 1})
+        @sut.find_contributor({"_id" => 42}, {"id" => 123})
+      end
+    end
+  end
+end

data/spec/duplicate_detector_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Jamnagar::Utilities::DuplicateDetector do
+  it 'should ask the store for duplicates' do
+    store = Jamnagar::SpecHelpers::SimpleItemStore.new
+    sut = Jamnagar::Utilities::DuplicateDetector.new(store)
+    expect(store).to receive(:find_first).with({"final_url" => "http://example.com"})
+    sut.detect("http://example.com")
+  end
+  context 'When Duplicates Exist' do
+    it 'should return duplicate details' do
+      store = double(Jamnagar::SpecHelpers::SimpleItemStore.new)
+      allow(store).to receive(:find_first).and_return({"_id" => 456})
+      sut = Jamnagar::Utilities::DuplicateDetector.new(store)
+      expect(sut.detect("http://example.com")).to eq({"_id" => 456})
+    end
+  end
+  context 'When No Duplicates Exist' do
+    it 'should not return duplicate details' do
+      store = double(Jamnagar::SpecHelpers::SimpleItemStore.new)
+      allow(store).to receive(:find_first).and_return(nil)
+      sut = Jamnagar::Utilities::DuplicateDetector.new(store)
+      expect(sut.detect("http://example.com")).to eq(nil)
+    end
+  end
+end

data/spec/helpers.rb

@@ -0,0 +1,92 @@
+require 'ostruct'
+
+module Jamnagar
+  module SpecHelpers
+    class PassThroughRunner
+      def run(&block)
+        block.call
+      end
+    end
+    class Parser
+      def self.HTML(string, *args)
+        string
+      end
+      def to_json
+        {}.to_json
+      end
+    end
+    class FakeHttpClient
+      def self.get(uri, opts={})
+        OpenStruct.new(:request => FakeRequest.new(uri))
+      end
+    end
+    class FakeRequest
+      class FakeUri
+        def initialize(uri)
+          @uri = uri
+        end
+        def host
+          "bit.ly"
+        end
+        def to_s
+          @uri
+        end
+      end
+      def initialize(uri)
+        @uri = uri
+      end
+      def last_uri
+        FakeUri.new(@uri)
+      end
+    end
+    class FakeCache
+      def get(key)
+        {}
+      end
+
+      def set(key, value)
+        {}
+      end
+    end
+    class FakeMongoDriver
+      def use(db=nil)
+        true
+      end
+    end
+    class FakeMongoCollection
+      def insert(value)
+        value
+      end
+      def find(params)
+        {}
+      end
+    end
+    class SimpleAdapter
+      def store(key, value)
+      end
+      def insert(record)
+        record
+      end
+
+      def [](key)
+
+      end
+      def find_first(params)
+      end
+    end
+    class SimpleItemStore
+      # A very simple item store
+      def insert(item)
+        true
+      end
+
+      def find_one(params)
+        params
+      end
+
+      def find_first(params)
+        {}
+      end
+    end
+  end
+end

data/spec/item_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Jamnagar::Materials::Item do
+  it 'should be able to merge refinements' do
+    sut = Jamnagar::Materials::Item.new
+    sut.merge_refinement({:foo => 'bar'})
+    expect(sut.to_h).to eq({:foo => 'bar'})
+  end
+end

data/spec/item_store_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Jamnagar::Storage::ItemStore do
+  context 'inserting records' do
+    it 'should ignore nil records' do
+      sut = Jamnagar::Storage::ItemStore.new
+      expect(lambda{ sut.insert(nil) }).to_not raise_exception
+    end
+    it 'should insert records using a primary key and value' do
+      sut = Jamnagar::Storage::ItemStore.new
+      sut.insert({"_id" => 1, "url" => "http://example.com"})
+    end
+    it 'should raise an exception if the primary key is missing' do
+      sut = Jamnagar::Storage::ItemStore.new
+      expect(lambda{ sut.insert({}) }).to raise_exception Jamnagar::Storage::ItemStore::MissingPrimaryKeyException
+    end
+  end
+end

data/spec/mongo_adapter_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Jamnagar::Adapters::MongoAdapter do
+  it 'should require a driver' do
+    driver = Jamnagar::SpecHelpers::FakeMongoDriver.new
+    sut = Jamnagar::Adapters::MongoAdapter.new(driver)
+  end
+
+  it 'should require a database name' do
+    driver = Jamnagar::SpecHelpers::FakeMongoDriver.new
+    expect(driver).to receive(:use).with("foo")
+    sut = Jamnagar::Adapters::MongoAdapter.new(driver, "foo")
+  end
+
+  it 'should require a collection name' do
+    sut = Jamnagar::Adapters::MongoAdapter.new(Jamnagar::SpecHelpers::FakeMongoDriver.new, "foo", "books")
+  end
+end

data/spec/popularity_incrementor_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Jamnagar::Utilities::PopularityIncrementor do
+  it 'should accept a store' do
+    store = {}
+    Jamnagar::Utilities::PopularityIncrementor.new(store)
+  end
+
+  it 'should increment the popularity of the original record' do
+    store = double(Jamnagar::Storage::BasicStore, :find_and_modify => {})
+    sut = Jamnagar::Utilities::PopularityIncrementor.new(store)
+    expect(store).to receive(:find_and_modify).with(:query => {"_id" => "123abc"}, :update => {"$inc" => {"popularity" => 1}})
+    sut.increment("123abc")
+  end
+
+  it 'should increment the popularity of the original record, based on id' do
+    store = double(Jamnagar::Storage::BasicStore, :find_and_modify => {})
+    sut = Jamnagar::Utilities::PopularityIncrementor.new(store)
+    expect(store).to receive(:find_and_modify).with(:query => {"_id" => "456efg"}, :update => {"$inc" => {"popularity" => 1}})
+    sut.increment("456efg")
+  end
+
+end

data/spec/producers_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe 'Producers' do
+  describe 'Twitter' do
+    it 'should exist' do
+      Jamnagar::Producers::TwitterProducer.new
+    end
+  end
+end

data/spec/refined_item_store_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'Refined Item Store' do
+  describe 'Adding Items' do
+    it 'should be able to add items to the store' do
+      item = {}
+      adapter = double(Jamnagar::Adapters::PersistentStoreAdapter)
+      expect(adapter).to receive(:insert).with(item)
+      sut = Jamnagar::Storage::RefinedItemStore.new(adapter)
+      sut.insert(item)
+    end
+  end
+
+  describe 'Querying for Duplicates' do
+    it 'should tell the adapter to find the duplicates' do
+      adapter = double(Jamnagar::Adapters::PersistentStoreAdapter)
+      sut = Jamnagar::Storage::RefinedItemStore.new(adapter)
+      expect(adapter).to receive(:find).with(1, "http://example.com")
+      sut.duplicates_of(1, "http://example.com")
+    end
+    it 'should return any results' do
+      items = [Jamnagar::Materials::Item.new, Jamnagar::Materials::Item.new]
+      adapter = double(Jamnagar::Adapters::MongoAdapter)
+      allow(adapter).to receive(:find).and_return(items)
+      sut = Jamnagar::Storage::RefinedItemStore.new(adapter)
+      expect(sut.duplicates_of(1,"http://example.com")).to eq items
+    end
+  end
+end

data/spec/refinements_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe 'Refinements' do
+  describe 'Generic Refiner' do
+    it 'should tell the item to merge the refinements' do
+      item = double(Jamnagar::Materials::Item, :merge_refinement => {})
+      expect(item).to receive(:merge_refinement).with({})
+      sut = Jamnagar::Refiners::Refiner.new
+      sut.refine(item)
+    end
+  end
+  describe 'Primary Key' do
+    it 'should tell the key generator to generate a primary key' do
+      item = Jamnagar::Materials::Item.new({"url" => "http://bit.ly/123"})
+      digester = double(Digest::MD5)
+
+      sut = Jamnagar::Refiners::PrimaryKeyGeneration.new(digester)
+      expect(digester).to receive(:hexdigest).with(item.to_s)
+      sut.refine(item)
+    end
+    it 'should return the generated key' do
+      item = Jamnagar::Materials::Item.new({"url" => "http://bit.ly/123"})
+      digester = double(Digest::MD5)
+
+      sut = Jamnagar::Refiners::PrimaryKeyGeneration.new(digester)
+      allow(digester).to receive(:hexdigest).and_return("abc123")
+      expect(sut.refine(item).to_h).to eq({"_id" => "abc123", "url" => "http://bit.ly/123"})
+    end
+  end
+  describe 'URL Expansion' do
+    it 'should tell the url expander to expand the shortened url' do
+      item = Jamnagar::Materials::Item.new({"url" => "http://bit.ly/123"})
+      expander = double(Jamnagar::Utilities::UrlExpander)
+
+      sut = Jamnagar::Refiners::UrlExpansion.new(expander)
+      expect(expander).to receive(:expand).with("http://bit.ly/123").and_return({})
+      sut.refine(item)
+    end
+    it 'should return details of the expanded url' do
+      item = Jamnagar::Materials::Item.new({"url" => "http://bit.ly/123"})
+      expander = double(Jamnagar::Utilities::UrlExpander)
+
+      sut = Jamnagar::Refiners::UrlExpansion.new(expander)
+      allow(expander).to receive(:expand).and_return({"final_url" => "http://example.com", "body" => "<html></html>", "final_url_host" => "example.com"})
+      expect(sut.refine(item).to_h).to eq({"url" => "http://bit.ly/123", "final_url" => "http://example.com", "final_url_host" => "example.com", "final_url_body" => "<html></html>"})
+    end
+  end
+  describe 'UTM Stripping' do
+    it 'should strip all utm related query string params' do
+      item = Jamnagar::Materials::Item.new({"final_url" => "http://bit.ly/123?utm_foo=123"})
+      stripper = double(Jamnagar::Utilities::UtmStripper)
+
+      sut = Jamnagar::Refiners::UtmStripping.new(stripper)
+      expect(stripper).to receive(:strip).with("http://bit.ly/123?utm_foo=123")
+      sut.refine(item)
+    end
+  end
+  describe 'Duplicates' do
+    it 'should tell the duplicate detector to detect duplicates' do
+      item = Jamnagar::Materials::Item.new({"final_url" => "http://bit.ly/123"})
+      detector = double(Jamnagar::Utilities::DuplicateDetector)
+
+      sut = Jamnagar::Refiners::DuplicateDetection.new(detector)
+      expect(detector).to receive(:detect).with("http://bit.ly/123")
+      sut.refine(item)
+    end
+    context 'when no duplicates are found' do
+      it 'should not return duplicates' do
+        item = Jamnagar::Materials::Item.new()
+        detector = double(Jamnagar::Utilities::DuplicateDetector)
+        sut = Jamnagar::Refiners::DuplicateDetection.new(detector)
+        allow(detector).to receive(:detect).and_return(nil)
+        expect(sut.refine(item).to_h).to eq({"duplicate" => false})
+      end
+    end
+    context 'when duplicates are found' do
+      it 'should return duplicate details' do
+        item = Jamnagar::Materials::Item.new()
+        detector = double(Jamnagar::Utilities::DuplicateDetector)
+        sut = Jamnagar::Refiners::DuplicateDetection.new(detector)
+        allow(detector).to receive(:detect).and_return({"_id" => 456})
+        expect(sut.refine(item).to_h).to eq({"duplicate" => true, "duplicate_of" => 456})
+      end
+    end
+  end
+  describe 'Popularity' do
+    context 'when the item is not a duplicate' do
+      it 'should not increment any items' do
+        item = Jamnagar::Materials::Item.new({"duplicate" => false})
+        incrementor = double(Jamnagar::Utilities::PopularityIncrementor)
+
+        sut = Jamnagar::Refiners::PopularityIncrementation.new(incrementor)
+        expect(incrementor).not_to receive(:increment).with("123")
+        sut.refine(item)
+      end
+    end
+    context 'when the item is a duplicate' do
+      it 'should tell the popularity incrementer to increment the popularity of the original item' do
+        item = Jamnagar::Materials::Item.new({"duplicate" => true, "duplicate_of" => "123"})
+        incrementor = double(Jamnagar::Utilities::PopularityIncrementor)
+
+        sut = Jamnagar::Refiners::PopularityIncrementation.new(incrementor)
+        expect(incrementor).to receive(:increment).with("123")
+        sut.refine(item)
+      end
+    end
+  end
+  describe 'Meta Data Extraction' do
+    it 'should tell the extractor to extract meta data' do
+      item = Jamnagar::Materials::Item.new({})
+      extractor = double(Jamnagar::Utilities::Twitter::MetaDataExtractor)
+
+      sut = Jamnagar::Refiners::Twitter::MetaDataExtraction.new(extractor)
+      expect(extractor).to receive(:extract).with(item)
+      sut.refine(item)
+    end
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Jamnagar::Utilities::Runner do
+  it 'should be' do
+    Jamnagar::Utilities::Runner.new
+  end
+
+end

data/spec/scenarios_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe 'Scenarios' do
+end

data/spec/source_detail_refinment_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Jamnagar::Refiners::SourceDetail do
+  it 'accepts a store' do
+    store = {}
+    Jamnagar::Refiners::SourceDetail.new(store: store)
+  end
+  it 'should look for the user in the source store' do
+    @item  = Jamnagar::Materials::Item.new({"final_url_host" => "example.com"})
+    @store = double(Jamnagar::Storage::SourceStore)
+    @sut   = Jamnagar::Refiners::SourceDetail.new(store: @store)
+
+    expect(@store).to receive(:find_source).with(@item, {"id" => "example.com"})
+    @sut.refine(@item)
+  end
+  it 'should return the details of the source' do
+    @item  = Jamnagar::Materials::Item.new({"final_url_host" => "example.org"})
+    @store = double(Jamnagar::Storage::SourceStore)
+    @sut   = Jamnagar::Refiners::SourceDetail.new(store: @store)
+    allow(@store).to receive(:find_source).and_return({"_id" => 999})
+
+    expect(@sut.refine(@item).to_h).to eq({"final_url_host" => "example.org", "source" => {"_id" => 999}})
+  end
+end

data/spec/source_store_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe Jamnagar::Storage::SourceStore do
+  context 'Finding Sources' do
+    before do
+      @adapter = double(Jamnagar::Adapters::MongoAdapter, :store => 123)
+      @sut = Jamnagar::Storage::SourceStore.new(@adapter)
+    end
+    context 'When the source exists' do
+      before do
+        @item = {"_id" => 2}
+        @existing = {"_id" => 123, "contributions" => [1]}
+        allow(@adapter).to receive(:find_first).and_return(@existing)
+      end
+      it 'should return the source' do
+        expect(@sut.find_source({}, {"id" => 123})).to eq(@existing)
+      end
+      it 'should update contributions on the source' do
+        expect(@adapter).to receive(:update).with({"_id" => 123}, {"$set" => {"contributions" => [1,2]}, "$inc" => {"contributions_count" => 1}})
+        @sut.find_source(@item, {"id" => 123})
+      end
+    end
+    context 'When the source does not exist' do
+      it 'should insert and return the record' do
+        allow(@adapter).to receive(:find_first).and_return(nil)
+        expect(@adapter).to receive(:store).with(123, {"id" => 123, "_id" => 123, "contributions" => [42], "contributions_count" => 1})
+        @sut.find_source({"_id" => 42}, {"id" => 123})
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,98 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+require_relative '../lib/jamnagar'
+require 'helpers'
+
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/url_expander_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Jamnagar::Utilities::UrlExpander do
+  it 'should have the option to use a cache' do
+    cache = {}
+    client = Jamnagar::SpecHelpers::FakeHttpClient
+    sut = Jamnagar::Utilities::UrlExpander.new(client, cache)
+  end
+
+  context 'Expanding Urls' do
+    it 'should first check the cache for the URL' do
+      cache = double(Jamnagar::SpecHelpers::FakeCache, :set => true)
+      client = Jamnagar::SpecHelpers::FakeHttpClient
+      sut = Jamnagar::Utilities::UrlExpander.new(client, cache)
+      expect(cache).to receive(:get).with("http://bit.ly/foo")
+      sut.expand("http://bit.ly/foo")
+    end
+    context 'cache miss' do
+      it 'should cache the expansion' do
+        cache = double(Jamnagar::SpecHelpers::FakeCache, :get => nil)
+        client = Jamnagar::SpecHelpers::FakeHttpClient
+        parser = Jamnagar::SpecHelpers::Parser
+        sut = Jamnagar::Utilities::UrlExpander.new(client, cache, parser)
+        expect(cache).to receive(:set).with("http://bit.ly/foo", {"final_url" => "http://bit.ly/foo", "body" => "null", "final_url_host" => "bit.ly"})
+        sut.expand("http://bit.ly/foo")
+      end
+    end
+    context 'cache hit' do
+      it 'should not try to expand the url' do
+        cache = Jamnagar::SpecHelpers::FakeCache.new
+        client = double(Jamnagar::SpecHelpers::FakeHttpClient)
+        sut = Jamnagar::Utilities::UrlExpander.new(client, cache)
+        expect(client).to_not receive(:get)
+        sut.expand("http://bit.ly/foo")
+      end
+      it 'should not try to cache the result' do
+        cache = Jamnagar::SpecHelpers::FakeCache.new
+        client = double(Jamnagar::SpecHelpers::FakeHttpClient)
+        sut = Jamnagar::Utilities::UrlExpander.new(client, cache)
+        expect(client).to_not receive(:get)
+        expect(cache).to_not receive(:set)
+        sut.expand("http://bit.ly/foo")
+      end
+    end
+  end
+end

data/spec/utm_stripper_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe 'UtmStripper' do
+  it 'should strip UTM query string params' do
+    dirty_url = "http://example.com/foo?utm_campaign=123"
+    clean_url = "http://example.com/foo"
+    sut = Jamnagar::Utilities::UtmStripper.new
+    expect(sut.strip(dirty_url)).to eq(clean_url)
+  end
+
+  it 'should strip mbid query string params' do
+    dirty_url = "http://example.com/foo?mbid=social_twitter"
+    clean_url = "http://example.com/foo"
+    sut = Jamnagar::Utilities::UtmStripper.new
+    expect(sut.strip(dirty_url)).to eq(clean_url)
+  end
+
+  it 'should strip hootPostID query string params' do
+    dirty_url = "http://example.com/foo?hootPostID=9db6f9a657df03e6cc250791fe8631ac"
+    clean_url = "http://example.com/foo"
+    sut = Jamnagar::Utilities::UtmStripper.new
+    expect(sut.strip(dirty_url)).to eq(clean_url)
+  end
+
+  it 'should leave other params alone' do
+    dirty_url = "http://example.com/foo?utm_campaign=123&foo=bar"
+    clean_url = "http://example.com/foo?foo=bar"
+    sut = Jamnagar::Utilities::UtmStripper.new
+    expect(sut.strip(dirty_url)).to eq(clean_url)
+  end
+end

data/spec/utm_stripping_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe 'UtmStripping' do
+
+end

data/spec/verifications_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe "Verifications" do
+  describe 'UniquenessVerifier' do
+    context "when the item is not unique" do
+      it 'should reject the item' do
+        store = double(Jamnagar::SpecHelpers::SimpleItemStore)
+        allow(store).to receive(:find_first).and_return({})
+        sut = Jamnagar::Verifiers::Twitter::UniquenessVerifier.new(store: store)
+        expect(sut.verify({})).to eq(nil)
+      end
+    end
+    context "when the item is unique" do
+      it 'should accept the item' do
+        store = double(Jamnagar::SpecHelpers::SimpleItemStore)
+        allow(store).to receive(:find_first).and_return(nil)
+        sut = Jamnagar::Verifiers::Twitter::UniquenessVerifier.new(store: store)
+        expect(sut.verify({})).to eq({})
+      end
+    end
+  end
+end