browsing_history 0.0.2

data/spec/browsing_history/history_spec.rb

@@ -0,0 +1,273 @@
+require 'spec_helper'
+require 'fixtures/user'
+require 'fixtures/article'
+
+describe BrowsingHistory::History do
+  let(:user)    { User.new }
+  let(:article) { Article.new }
+  let(:articles) { Array.new(50) { |i| Article.new(i) } }
+  let(:history) { described_class.new(browser: user, historizable: article) }
+  let(:invalid_object) { Struct.new(:_).new }
+
+  describe 'responses' do
+    describe 'instance_methods' do
+      subject { history }
+
+      it { is_expected.to respond_to(:browser) }
+      it { is_expected.to respond_to(:historizable) }
+      it { is_expected.to respond_to(:save) }
+      it { is_expected.to respond_to(:save!) }
+    end
+
+    describe 'instance_methods' do
+      subject { described_class }
+
+      it { is_expected.to respond_to(:create) }
+      it { is_expected.to respond_to(:create!) }
+      it { is_expected.to respond_to(:where) }
+      it { is_expected.to respond_to(:count) }
+    end
+  end
+
+  describe '#save' do
+    let(:new_history_with_valid_objects) do
+      described_class.new(
+        browser: user,
+        historizable: article
+      )
+    end
+
+    let(:new_history_with_invalid_browser) do
+      described_class.new(
+        browser: invalid_object,
+        historizable: article
+      )
+    end
+
+    let(:new_history_with_invalid_historizable) do
+      described_class.new(
+        browser: user,
+        historizable: invalid_object
+      )
+    end
+
+    context 'when save with valid objects' do
+      it "should return #{described_class} instance" do
+        expect(
+          new_history_with_valid_objects.save
+        ).to be(true)
+
+        expect(
+          new_history_with_valid_objects.save!
+        ).to be(true)
+      end
+    end
+
+    context 'when save with invalid object' do
+      it 'should return nil' do
+        expect(
+          new_history_with_invalid_browser.save
+        ).to be_falsey
+
+        expect(
+          new_history_with_invalid_historizable.save
+        ).to be_falsey
+      end
+    end
+
+    context 'when save! with invalid object' do
+      it 'should raise error' do
+        expect do
+          new_history_with_invalid_browser.save!
+        end.to raise_error(BrowsingHistory::History::ArgumentError)
+
+        expect do
+          new_history_with_invalid_historizable.save!
+        end.to raise_error(BrowsingHistory::History::ArgumentError)
+      end
+    end
+
+    context 'after save hitorizables' do
+      before(:each) do
+        articles.each do |article|
+          described_class.new(browser: user, historizable: article).save
+        end
+      end
+
+      let(:saved_articles) do
+        described_class.where(
+          browser: user,
+          historizable: article
+        )
+      end
+
+      it 'should equal original historizable' do
+        saved_articles.each_with_index do |saved_article, i|
+          original = articles.reverse[i]
+
+          expect(saved_article.id).to eq(original.id)
+          expect(saved_article.title).to eq(original.title)
+        end
+      end
+    end
+
+    context 'after save! hitorizables' do
+      before(:each) do
+        articles.each do |article|
+          described_class.new(browser: user, historizable: article).save!
+        end
+      end
+
+      let(:saved_articles) do
+        described_class.where(
+          browser: user,
+          historizable: article
+        )
+      end
+
+      it 'should equal original historizable' do
+        saved_articles.each_with_index do |saved_article, i|
+          original = articles.reverse[i]
+
+          expect(saved_article.id).to eq(original.id)
+          expect(saved_article.title).to eq(original.title)
+        end
+      end
+    end
+  end
+
+  describe '.create' do
+    context 'when create with valid objects' do
+      subject do
+        described_class.create(
+          browser: user,
+          historizable: article
+        )
+      end
+      it { is_expected.to be_a(described_class) }
+
+      subject do
+        described_class.create!(
+          browser: user,
+          historizable: article
+        )
+      end
+      it { is_expected.to be_a(described_class) }
+    end
+
+    context 'when create with invalid object' do
+      it 'should return nil' do
+        expect(
+          described_class.create(
+            browser: invalid_object,
+            historizable: article
+          )
+        ).to be_falsey
+
+        expect(
+          described_class.create(
+            browser: user,
+            historizable: invalid_object
+          )
+        ).to be_falsey
+      end
+    end
+
+    context 'when create! with invalid object' do
+      it 'should raise error' do
+        expect do
+          described_class.create!(
+            browser: invalid_object,
+            historizable: article
+          )
+        end.to raise_error(BrowsingHistory::History::ArgumentError)
+
+        expect do
+          described_class.create!(
+            browser: user,
+            historizable: invalid_object
+          )
+        end.to raise_error(BrowsingHistory::History::ArgumentError)
+      end
+    end
+  end
+
+  describe '.count' do
+    subject { described_class.current_storage.count(user, article) }
+    it { is_expected.to eq(0) }
+  end
+
+  describe '.where' do
+    it 'should default empty' do
+      expect(
+        BrowsingHistory::History.where(
+          browser: user,
+          historizable: article
+        )
+      ).to be_empty
+    end
+
+    context 'with limit option' do
+      before do
+        5.times do |i|
+          described_class.create(browser: user, historizable: Article.new(i))
+        end
+      end
+
+      let(:historizables) do
+        described_class.where(
+          browser: user,
+          historizable: article,
+          limit: 3
+        )
+      end
+
+      let(:historizables_excess_limit) do
+        described_class.where(
+          browser: user,
+          historizable: article,
+          limit: 100
+        )
+      end
+
+      it { expect(historizables).to be_a(Array) }
+      it { expect(historizables.size).to eq(3) }
+
+      it { expect(historizables_excess_limit).to be_a(Array) }
+      it { expect(historizables_excess_limit.size).to eq(5) }
+    end
+
+    context 'with between option' do
+      before do
+        5.times.map.with_index(1) do |i|
+          described_class.create(browser: user, historizable: Article.new(i))
+        end
+
+        sleep(6)
+        described_class.create(browser: user, historizable: Article.new(100))
+      end
+
+      let(:historizables) do
+        described_class.where(
+          browser: user,
+          historizable: article,
+          between: Time.now..5.seconds.ago
+        )
+      end
+
+      let(:historizables_unhit) do
+        described_class.where(
+          browser: user,
+          historizable: article,
+          between: 1.day.ago..2.days.ago
+        )
+      end
+
+      it { expect(historizables).to be_a(Array) }
+      it { expect(historizables.size).to eq(1) }
+
+      it { expect(historizables_unhit).to be_a(Array) }
+      it { expect(historizables_unhit.size).to eq(0) }
+    end
+  end
+end

data/spec/browsing_history/storage_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe BrowsingHistory::Storage do
+  describe '#attach_storage' do
+    let(:default_storage) { :redis }
+
+    let(:include_class) do
+      Struct.new(:_) do
+        include BrowsingHistory::Storage
+      end
+    end
+
+    let(:include_class_attached_activerecord) do
+      Struct.new(:_) do
+        include BrowsingHistory::Storage
+        attach_storage :active_record
+      end
+    end
+
+    let(:include_class_invalid_storage) do
+      Struct.new(:_) do
+        include BrowsingHistory::Storage
+        attach_storage :invalid_storage
+      end
+    end
+
+    it 'should be attached redis storage default' do
+      expect(include_class.current_storage_type).to eql(default_storage)
+    end
+
+    it 'should attached activerecord' do
+      expect(
+        include_class_attached_activerecord.current_storage_type
+      ).to eql(:active_record)
+    end
+
+    context 'when passed invalid storage' do
+      it 'should raise error' do
+        expect do
+          include_class_invalid_storage
+        end.to raise_error(BrowsingHistory::Storage::InvalidStorage)
+      end
+    end
+  end
+end

data/spec/browsing_history/storages/base_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'fixtures/user'
+require 'fixtures/article'
+
+describe BrowsingHistory::Storages::Base do
+  let(:user)     { User.new }
+  let(:article)  { Article.new }
+  let(:described_instance) { described_class.new(user, article) }
+  let(:test_options) { Hash.new }
+
+  before do
+    described_class.connect
+  end
+
+  describe 'io_methods' do
+    it 'should be defined on class' do
+      BrowsingHistory::Storages::IOMethods.each do |method|
+        expect(
+          described_class.respond_to?(method)
+        ).to be(true)
+      end
+    end
+
+    it 'should raise not overide error' do
+      BrowsingHistory::Storages::IOMethods.each do |method|
+        expect do
+          described_instance.send(method)
+        end.to raise_error(BrowsingHistory::Storages::NotOverideError)
+      end
+    end
+  end
+
+  describe '.connect' do
+  end
+end

data/spec/browsing_history/storages/redis_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+require 'fixtures/user'
+require 'fixtures/article'
+
+describe BrowsingHistory::Storages::Redis do
+  articles_size = 5
+
+  let(:user)    { User.new }
+  let(:articles) do
+    articles_size.times.map.with_index(1) { |i| Article.new(i) }
+  end
+  let(:article) { articles.first }
+
+  let(:storage) do
+    Struct.new(:_) do
+      include BrowsingHistory::Storage
+      attach_storage :redis
+    end.current_storage
+  end
+
+  describe 'method_defined?' do
+    describe 'public_instance_methods' do
+      subject { storage.new(user, article) }
+
+      it { is_expected.to respond_to(:fetch) }
+      it { is_expected.to respond_to(:add) }
+      it { is_expected.to respond_to(:update) }
+      it { is_expected.to respond_to(:clear) }
+      it { is_expected.to respond_to(:interface) }
+    end
+
+    describe 'private_instance_methods' do
+      subject { storage.private_instance_methods }
+
+      it { is_expected.to include(:history) }
+      it { is_expected.to include(:fetch_between) }
+      it { is_expected.to include(:clear_all) }
+      it { is_expected.to include(:clear_expiration) }
+      it { is_expected.to include(:score) }
+      it { is_expected.to include(:parse_between) }
+    end
+
+    describe 'singleton_methods' do
+      subject { storage }
+      it { is_expected.to respond_to(:connect) }
+      it { is_expected.to respond_to(:default_options) }
+      it { is_expected.to respond_to(:default_connect_options) }
+
+      it { is_expected.to respond_to(:redis) }
+      it { is_expected.to respond_to(:set) }
+    end
+  end
+
+  describe '#fetch' do
+    context 'when add 1 object' do
+      it 'should return articles' do
+        expect { storage.add(user, article) }
+          .to change { storage.fetch(user, article).size }.by(1)
+      end
+    end
+
+    context "when add #{articles_size} object" do
+      it 'should return articles' do
+        expect do
+          articles.each { |article| storage.add(user, article) }
+        end.to change { storage.fetch(user, article).size }.by(articles_size)
+      end
+    end
+  end
+
+  describe '#add' do
+    let(:history_key) do
+      %(\
+        #{user.browser_type}/\
+        #{user.browser_id}/\
+        #{article.historizable_type}\
+      ).delete(' ')
+    end
+
+    context 'when add 1 object' do
+      before { storage.add(user, article) }
+      it { expect(storage.redis.exists(history_key)).to be(true) }
+    end
+  end
+
+  describe '#update' do
+  end
+
+  describe '#clear' do
+    before(:each) { articles.each { |article| storage.add(user, article) } }
+
+    it 'should clear 1 historizable' do
+      expect { storage.clear(user, article, article) }
+        .to change { storage.fetch(user, article).size }.by(-1)
+    end
+
+    it 'should celar all historizables' do
+      expect { storage.clear(user, article, all: true) }
+        .to change { storage.fetch(user, article).size }.to(0)
+    end
+
+    context 'and add 1 historizable after 6 seconds' do
+      before do
+        sleep(6)
+        storage.add(user, Article.new(100))
+      end
+
+      it 'should celar 5 historizables' do
+        expect { storage.clear(user, article, expiration: 5.seconds.ago) }
+          .to change { storage.fetch(user, article).size }.to(1)
+      end
+    end
+  end
+
+  describe '#count' do
+    before(:each) { articles.each { |article| storage.add(user, article) } }
+
+    context "when exist #{articles_size} historizable" do
+      subject { storage.count(user, article) }
+      it { is_expected.to be(articles_size) }
+    end
+
+    context 'and add 1 historizable after 6 seconds' do
+      before do
+        sleep(6)
+        storage.add(user, Article.new(100))
+      end
+
+      subject { storage.count(user, article, between: Time.now..5.seconds.ago) }
+      it { is_expected.to be(1) }
+    end
+  end
+
+  describe '#interface' do
+    subject { storage.set }
+    it { is_expected.to be(Redis::SortedSet) }
+  end
+
+  describe '.connect' do
+  end
+end

data/spec/browsing_history_spec.rb

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

data/spec/generator_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'generator_spec'
+require 'generator_spec/test_case'
+
+require 'generators/active_record/migration_generator'
+
+describe BrowsingHistory::MigrationGenerator, type: :generator do
+  include GeneratorSpec::TestCase
+  destination File.expand_path('tmp', __dir__)
+
+  after(:all) { prepare_destination } # cleanup the tmp directory
+
+  describe 'no options' do
+    before(:all) do
+      prepare_destination
+      run_generator
+    end
+
+    it 'generates a migration for creating browsing_histories table' do
+      expect(destination_root).to have_structure do
+        directory 'db' do
+          directory 'migrate' do
+            migration 'create_browsing_histories' do
+              contains 'class CreateBrowsingHistories'
+              contains 'def up'
+              contains 'create_table :browsing_histories'
+              contains 'def down'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+ENV['RAILS_ENV'] ||= 'test'
+ENV['DB']        ||= 'sqlite'
+
+require 'pry'
+require 'rails/all'
+require 'rspec/rails'
+require 'database_cleaner'
+
+require 'browsing_history'
+
+$LOAD_PATH.unshift File.expand_path(__dir__)
+$LOAD_PATH.unshift File.expand_path('browsing_history', __dir__)
+
+require File.expand_path('test_app/config/environment', __dir__)
+
+RSpec.configure do |config|
+  redis = BrowsingHistory::History.storages[:redis].redis
+
+  config.mock_with :rspec
+  config.before(:suite) do
+    DatabaseCleaner[:redis].db = redis.client.id
+    DatabaseCleaner.strategy = :truncation
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+    DatabaseCleaner.clean
+    redis.flushdb
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+    redis.redis.quit
+  end
+end
+
+def random_string(length = 8)
+  (0...length).map { (65 + rand(26)).chr }.join
+end

data/spec/test_app/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/spec/test_app/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks

data/spec/test_app/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/spec/test_app/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/spec/test_app/app/controllers/application_controller.rb

@@ -0,0 +1,10 @@
+class ApplicationController < ApplicationController
+  before_action :set_user
+
+  private
+
+  def set_user
+    @user = User.new
+  end
+end
+

data/spec/test_app/app/controllers/articles_controller.rb

@@ -0,0 +1,17 @@
+class AriclesController < ApplicationController
+  before_action :set_article
+  before_action :add_user_history
+
+  def show
+  end
+
+  private
+
+  def set_article
+    @article = Article.new
+  end
+
+  def add_user_history
+
+  end
+end

data/spec/test_app/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end