neutral 0.0.1

data/spec/helpers/action_view_extension_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe "#voting_for", type: :feature do
+  class View < ActionView::Base.extend(Neutral::Helpers::ActionViewExtension)
+    def current_voter;end
+  end
+
+  def view
+    @view ||= View.new
+  end
+
+  let(:voteable) { FactoryGirl.create(:post) }
+
+  context "when a valid object" do
+    it "builds a voting" do
+      Neutral::VotingBuilder::Builder.should_receive(:new).with(voteable, hash_including(:voter)).and_call_original
+      Neutral::VotingBuilder::Builder.any_instance.should_receive(:build)
+      view.voting_for voteable
+    end
+  end
+
+  context "when an invalid object" do
+    it "raises InvalidVoteableObject error" do
+      expect { voting_for "not a voteable object" }.to raise_error
+    end
+  end
+
+  context "with difference" do
+    it "builds a voting with difference" do
+      Neutral::VotingBuilder::Builder.should_receive(:new).with(voteable, hash_including(:voter, difference: true)).and_call_original
+      Neutral::VotingBuilder::Builder.any_instance.should_receive(:build)
+      view.voting_for voteable, difference: true
+    end
+  end
+
+  context "with specific icon set" do
+    let(:icons) { :operations }
+
+    it "builds a voting with specific icon set" do
+      Neutral::VotingBuilder::Builder.should_receive(:new).with(voteable, hash_including(:voter, icons: icons)).and_call_original
+      Neutral::VotingBuilder::Builder.any_instance.should_receive(:build)
+      view.voting_for voteable, icons: icons
+    end
+  end
+end

data/spec/icons/collection_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Neutral::Icons::Collection do
+  let(:collection) { Neutral::Icons::Collection.new }
+  let(:set) { Neutral::Icons::Set.new(:my_test_icons) }
+
+  describe "#add" do
+    context "when given set already exists" do
+      let(:set) { Neutral::Icons::Set.new(:thumbs) }
+
+      it "raises AlreadyDefinedIconSet error" do
+        expect { collection.add(set.name, set.definitions) }.to raise_error
+      end
+    end
+
+    context "when given set does not exist yet" do
+      it "defines method on icons object with given set name and definitions" do
+        collection.should_receive(:define!).with(set.name, set.definitions)
+        collection.add(set)
+      end
+    end
+  end
+
+  describe "#define!" do
+    before do
+      collection.send(:define!, set.name, set.definitions)
+    end
+
+    subject { collection.send(set.name) }
+
+    it { should be_a(Neutral::Icons::Collection::Definitions) }
+
+    [:positive, :negative, :remove].each do |definition|
+      its(definition) { should == set.definitions[definition] }
+    end
+  end
+end
+

data/spec/icons/set_spec.rb

@@ -0,0 +1,25 @@
+describe Neutral::Icons::Set do
+  let(:set) { Neutral::Icons::Set.new('my_test_icons') }
+  
+  describe "#name" do
+    subject { set.name }
+    it { should be_a(Symbol) }
+  end
+  
+  describe "#definitions" do
+    subject { set.definitions }
+    it { should be_a(Hash) }
+    it { should == Neutral.icons.send(Neutral.config.default_icon_set).to_h }
+  end
+
+  %w[positive negative remove].each do |definition|
+    describe definition do
+      let(:fa_definition) { "fa #{definition}" }
+
+      it "adds Font Awesome definition for #{definition} icon to definitions" do
+        set.send(definition, fa_definition)
+        set.definitions[definition.to_sym].should == fa_definition
+      end
+    end
+  end
+end 

data/spec/models/active_record_extension_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+extended = ActiveRecord::Base.extend(Neutral::Model::ActiveRecordExtension)
+
+class Item < extended
+  neutral
+end
+
+class Client < extended
+  neutral_voter
+end
+
+describe Item, type: :model do
+  it { should be_a(Neutral::Model::ActiveRecordExtension::Voteable) }
+
+  before do
+    @migration = ActiveRecord::Migration.new
+    @migration.verbose = false
+    @migration.create_table(:items)
+  end
+
+  after do
+    @migration.drop_table(:items)
+  end
+
+  describe "#neutral" do
+    it { should have_many(:votes) }
+    it { should have_many(:voters) }
+    it { should have_one(:voting) }
+  end
+end
+
+describe Client, type: :model do
+  it { should be_a(Neutral::Model::ActiveRecordExtension::Voter) }
+
+  before do
+    @migration = ActiveRecord::Migration.new
+    @migration.verbose = false
+    @migration.create_table(:clients)
+  end
+
+  after do
+    @migration.drop_table(:clients)
+  end
+
+  describe "#neutral_voter" do
+    it { should have_many(:votes_given) }
+  end
+end

data/spec/models/vote_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Neutral::Vote do
+  it { should belong_to :voteable }
+  it { should belong_to :voter }
+  it { validate_presence_of :voteable_type }
+  it { validate_presence_of :voteable_id }
+  it { validate_presence_of :value }
+  it { should ensure_inclusion_of(:value).in_range(0..1) }
+  
+  let!(:vote) { FactoryGirl.create(:vote) }
+
+  describe "before_update" do
+    it "avoids duplication" do
+      expect { vote.update_attributes(value: vote.value) }.to raise_error
+    end
+  end
+  
+  describe "after_create" do
+    context "when vote's voting does not exist yet" do
+      it "adds vote to voting" do
+        Neutral::Voting.should_receive(:init).with(FactoryGirl.create(:vote))
+      end
+    end
+
+    context "when vote's voting already exists" do
+      let(:another_vote) { FactoryGirl.create(:vote, voteable: vote.voteable) }
+
+      it "adds vote to an existing voting" do
+        vote.voting.should_receive(:add_to_existing).with(another_vote.nature)
+      end
+    end
+  end
+  
+  describe "after_update" do
+    let(:opposite) { vote.value == 1 ? :negative : :positive }
+
+    it "edits vote within voting" do
+      vote.voting.should_receive(:edit).with(opposite)
+      vote.update_attributes(value: vote.value.eql?(1) ? 0 : 1)
+    end
+  end
+  
+  describe "after_destroy" do
+    it "removes vote from voting" do
+      vote.voting.should_receive(:remove).with(vote.nature)
+      vote.destroy
+    end
+  end
+end
+

data/spec/models/voting_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Neutral::Voting do
+  it { should belong_to(:votingable) }
+  
+  let(:voting) { Neutral::Voting.create }
+  let(:nature) { [:positive, :negative].sample }
+
+  describe "#difference" do
+    let(:positive) { rand(100) }
+    let(:negative) { rand(100) }
+
+    subject { Neutral::Voting.new(positive: positive, negative: negative).difference }
+    it { should == positive - negative }
+  end
+
+  describe "#self.init" do
+    let(:vote) { FactoryGirl.build(:vote) }
+
+    subject { Neutral::Voting.init(vote) }
+
+    it { should be_a(Neutral::Voting) }
+    it { should be_persisted }
+    its(:votingable_type) { should == vote.voteable_type } 
+    its(:votingable_id) { should == vote.voteable_id }
+    it { subject.send(vote.nature).should == 1 }
+  end
+
+  describe "#add_to_existing" do
+    it "adds vote to an existing voting" do
+      voting.should_receive(:increment!).with(nature)
+      voting.add_to_existing(nature)
+    end
+  end
+
+  describe "#edit" do
+    it "edits vote withing voting" do
+      voting.should_receive(:increment).with(nature)
+      voting.should_receive(:decrement).with(nature==:positive ? :negative : :positive)
+      voting.should_receive(:save)
+      voting.edit(nature)
+    end
+  end
+
+  describe "#remove" do
+    it "removes vote from voting" do
+      voting.should_receive(:decrement!).with(nature)
+      voting.remove(nature)
+    end
+  end
+
+  describe "before_destroy" do
+    let(:voting) { FactoryGirl.create(:vote).voting }
+
+    it "deletes voting's votes" do
+      voting.votes.should_receive(:delete_all)
+      voting.destroy
+    end
+  end 
+end

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+require 'simplecov'
+SimpleCov.start
+
+ENV['RAILS_ENV'] ||= 'test'
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require 'rspec/rails'
+require 'ffaker'
+require 'factory_girl_rails'
+require 'capybara/rspec'
+require 'remarkable_activerecord'
+require 'shoulda-matchers'
+require 'database_cleaner'
+require 'debugger'
+require 'pry-rails'
+
+Rails.backtrace_cleaner.remove_silencers!
+ENGINE_RAILS_ROOT=File.join(File.dirname(__FILE__), '../')
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.mock_with :rspec
+  config.use_transactional_fixtures = false
+  config.infer_base_class_for_anonymous_controllers = true
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.strategy = :transaction
+  end
+
+  config.before(:each, :js => true) do
+    DatabaseCleaner.strategy = :truncation
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end

data/spec/support/shared_examples/controller_examples.rb

@@ -0,0 +1,45 @@
+shared_examples "unable to change" do |action|
+  context "when cannot change" do
+    context "when not permitted to change" do
+      before do
+        Neutral.configure { |config| config.can_change = false }
+        controller.stub(:current_user).and_return(vote.voter)
+      end
+    
+      after do
+        Neutral.configure { |config| config.can_change = true }
+      end 
+
+      it_should_behave_like "not performing #{action}"
+    end
+    
+    context "when current_user is not an owner of the vote" do
+      before do
+        controller.stub(:current_user).and_return(voter)
+      end
+
+      it_should_behave_like "not performing #{action}"
+    end
+  end
+end
+
+shared_examples "not performing update" do
+  it "does not update the vote" do
+    update(vote)
+    vote.value.should == vote.reload.value
+  end
+
+  it "renders cannot_change template" do
+    expect(update(vote)).to render_template('errors/cannot_change')
+  end
+end
+
+shared_examples "not performing destroy" do
+  it "does not destroy the vote" do
+    expect { destroy(vote) }.to_not change(Neutral::Vote, :count).by(-1)
+  end
+
+  it "renders cannot_change template" do
+    expect(destroy(vote)).to render_template('errors/cannot_change')
+  end
+end

data/spec/support/votes_controller_base_class.rb

@@ -0,0 +1,28 @@
+module VotesControllerBaseClass
+  extend ActiveSupport::Concern
+  
+  included do
+    controller do
+      rescue_from Neutral::Errors::RequireLogin, with: :require_login
+      rescue_from Neutral::Errors::CannotChange, with: :cannot_change
+      rescue_from Neutral::Errors::DuplicateVote, with: :duplicate
+
+      def current_voter
+        send Neutral.config.current_voter_method
+      end
+
+      private
+      def require_login
+        render 'neutral/votes/errors/require_login', status: 401
+      end
+
+      def cannot_change
+        render 'neutral/votes/errors/cannot_change', status: 403
+      end
+
+      def duplicate
+        render 'neutral/votes/errors/duplicate', status: 409
+      end
+    end
+  end
+end

data/spec/support/votes_controller_helpers.rb

@@ -0,0 +1,24 @@
+module VotesControllerHelpers
+  def create(voteable)
+    xhr :post, :create, 
+      vote: { 
+        voteable_type: voteable.class.name,
+        voteable_id: voteable.id,
+        value: rand(0..1)
+      } 
+  end
+
+  def update(vote, duplicate=false)
+    xhr :patch, :update, id: vote.id, value: value(vote.value, duplicate)
+  end
+
+  def destroy(vote)
+    xhr :delete, :destroy, id: vote.id
+  end
+
+  private
+  def value(val, duplicate)
+    return val if duplicate
+    val == 1 ? 0 : 1
+  end
+end

data/spec/voting_builder/builder_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Neutral::VotingBuilder::Builder, type: :feature do
+  describe "#build" do
+    let(:voteable) { FactoryGirl.create(:post) }
+    let(:vote) { FactoryGirl.create(:vote) }
+
+    context "basic built" do
+      subject { Neutral::VotingBuilder::Builder.new(voteable, {}).build }
+
+      it { should have_selector "div.neutral" }
+      it { should have_selector "span#positive" }
+      it { should have_selector "a.positive" }
+      it { should have_selector "a.negative" }
+      it { should have_selector "span#negative" }
+    end
+
+    context "with difference" do
+      subject { Neutral::VotingBuilder::Builder.new(voteable, difference: true).build }
+
+      it { should have_selector "span#difference" }
+      it { should_not have_selector "span#positive" }
+      it { should_not have_selector "span#negative" }
+    end
+
+    describe "remove link" do
+      context "when present" do
+        before do
+          Neutral.configure { |config| config.can_change = true }
+        end
+
+        subject { Neutral::VotingBuilder::Builder.new(vote.voteable, voter: vote.voter).build }
+
+        it { should have_selector "a.remove" }
+      end
+
+      context "when not present" do
+        context "when current voter has not voted yet or is not an owner of the vote" do
+          let(:voteable) { vote.voteable }
+          let(:voter) { vote.voter }
+
+          before do
+            vote.destroy
+          end
+
+          subject { Neutral::VotingBuilder::Builder.new(voteable, voter: voter).build }
+          it { should_not have_selector "a.remove" }
+        end
+
+        context "when current voter has voted but cannot change the vote" do
+          before do
+            Neutral.configure { |config| config.can_change = false }
+          end
+
+          after do
+            Neutral.configure { |config| config.can_change = true }
+          end
+
+          subject { Neutral::VotingBuilder::Builder.new(vote.voteable, voter: vote.voter).build }
+          
+          it { should_not have_selector("a.remove") }
+        end
+      end
+    end
+  end
+end

data/spec/voting_builder/elements/link_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+include Neutral::VotingBuilder::Elements
+
+describe Link, type: :feature do
+  let(:vote) { FactoryGirl.create(:vote) }
+
+  [Link::Positive, Link::Negative, Link::Remove].each do |link|
+    describe link do
+      let(:klass) { link.to_s.demodulize.downcase }
+      let(:router) { Neutral::VotingBuilder::Router.new(vote).send(klass) }
+      let(:icon) { "fa-#{klass}" }
+
+      subject { Capybara.string link.new(router, icon).to_s }
+
+      it { should have_selector("a.#{klass}") }
+
+      it "has corresponding path" do
+        subject.find("a.#{klass}")[:href].should include(router[:path])
+      end
+
+      it "has corresponding HTTP method" do
+        subject.find("a.#{klass}")["data-method"].should == router[:method]
+      end
+
+      it "has valid FontAwesome icon class" do
+        subject.find("i")[:class].should == "fa #{icon}"
+      end
+    end
+  end
+end

data/spec/voting_builder/elements/span_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+include Neutral::VotingBuilder::Elements
+    
+describe Span, type: :feature do
+  [Span::Positive, Span::Negative].each do |span|
+    describe span do
+      describe "#to_s" do
+        let(:total) { rand(100) + 1 }
+
+        subject { Capybara.string span.new(total).to_s }
+
+        it { should have_selector("span##{span.to_s.demodulize.downcase}") }
+
+        it "has value of given total" do
+          subject.find("span").text.should == total.to_s
+        end
+
+        it "nullifies total of zero" do
+          Capybara.string(span.new(0).to_s).text.should == ""
+        end
+      end
+    end
+  end
+
+  describe Span::Difference do
+    describe "#to_s" do
+      let(:positive) { rand(100) + 1 }
+      let(:negative) { -(rand(100) + 1) }
+
+      it "has absolute value of total" do
+        Capybara.string(Span::Difference.new(negative).to_s).find("span").text.to_i.should > 0
+      end                       
+
+      it "has 'positive' class when positive value of total is passed" do
+        Capybara.string(Span::Difference.new(positive).to_s).find("span")[:class].should == "positive"    
+      end
+
+      it "has 'negative' class when negative value of total is passed" do
+        Capybara.string(Span::Difference.new(negative).to_s).find("span")[:class].should == "negative"    
+      end
+    end
+  end
+end

data/spec/voting_builder/router_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Neutral::VotingBuilder::Router do
+  include Neutral::Engine.routes.url_helpers
+
+  context "for a persisted vote" do
+    let(:vote) { FactoryGirl.create(:vote) }
+
+    subject { Neutral::VotingBuilder::Router.new(vote) }
+
+    describe "#positive" do
+      subject { super().positive }
+
+      its([:path]) { should eq(vote_path(vote, value: 1)) }
+      its([:method]) { should eq('patch') }
+    end
+
+    describe "#negative" do
+      subject { super().negative }
+
+      its([:path]) { should eq(vote_path(vote, value: 0)) }
+      its([:method]) { should eq('patch') }
+    end
+
+    describe "#remove" do
+      subject { super().remove }
+
+      its([:path]) { should eq(vote_path(vote)) }
+    end
+  end
+
+  context "for a not persisted vote" do
+    let(:vote) { FactoryGirl.build(:vote) }
+
+    subject { Neutral::VotingBuilder::Router.new(vote) }
+
+    describe "#positive" do
+      subject { super().positive }
+
+      its([:path]) { should eq(votes_path(vote: vote.main_attributes.merge(value: 1))) }
+      its([:method]) { should eq('post') }
+    end
+
+    describe "#negative" do
+      subject { super().negative }
+
+      its([:path]) { should eq(votes_path(vote: vote.main_attributes.merge(value: 0))) }
+      its([:method]) { should eq('post') }
+    end
+
+    describe "#remove" do
+      subject { -> { super().remove } }
+
+      it { should raise_error }
+    end
+  end
+end

data/spec/voting_builder/structure_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Neutral::VotingBuilder::Structure do
+  let(:random) { [true, false].sample }
+
+  describe "#to_a" do
+    describe "spans" do
+      context "when not difference" do
+        subject { Neutral::VotingBuilder::Structure.new(random, false).to_a }
+
+        it { should include("positive_span") }
+        it { should include("negative_span") }
+        it { should_not include("difference_span") }
+      end
+
+      context "when difference" do
+        subject { Neutral::VotingBuilder::Structure.new(random, true).to_a }
+
+        it { should_not include("positive_span") }
+        it { should_not include("negative_span") }
+        it { should include("difference_span") }
+      end
+    end
+
+    describe "remove link" do
+      context "when present" do
+        before do
+          Neutral.configure { |config| config.can_change = true }
+        end
+
+        subject { Neutral::VotingBuilder::Structure.new(true, random).to_a }
+
+        it { should include("remove_link") }
+      end
+
+      context "when not present" do
+        context "when vote is not persisted" do
+          subject { Neutral::VotingBuilder::Structure.new(false, random).to_a }
+
+          it { should_not include("remove_link") }
+        end
+
+        context "when voter cannot change his vote" do
+          before do
+            Neutral.configure { |config| config.can_change = false }
+          end
+
+          after do
+            Neutral.configure { |config| config.can_change = true }
+          end
+
+          subject { Neutral::VotingBuilder::Structure.new(true, random).to_a }
+
+          it { should_not include("remove_link") }
+        end
+      end
+    end
+  end
+end