exposition 0.0.3.pre.alpha

data/lib/exposition/engine.rb

@@ -0,0 +1,14 @@
+module Exposition
+  class Engine < ::Rails::Engine
+    isolate_namespace Exposition
+    config.generators do |g|
+      g.test_framework      :rspec,        :fixture => false
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+    initializer "exposition.assets.precompile" do |app|
+        app.config.assets.precompile += %w( exposition/twitter.svg )
+    end
+  end
+end

data/lib/exposition/setup.rb

@@ -0,0 +1,15 @@
+require 'thor'
+
+module Exposition
+  class Setup < Thor
+    desc 'create_user', 'creates an admin user'
+    method_option :attributes,
+      type: :hash,
+      required: true,
+      desc: 'specifies attributes for your user account. eg. name:Johnny email:john@exposition.com password:secret password_confirmation:secret'
+    def create_user
+      user_attributes = options.fetch('attributes')
+      ::Exposition::User.create!(user_attributes)
+    end
+  end
+end

data/lib/exposition/version.rb

@@ -0,0 +1,3 @@
+module Exposition
+  VERSION = "0.0.3-alpha"
+end

data/lib/tasks/exposition_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task exposition: :environment do
+#   puts Exposition::User.last
+# end

data/lib/tasks/setup.rb

@@ -0,0 +1,17 @@
+# Load associated Rails environment if there is a Rails environment
+# require 'exposition/engine' if defined? ::Rails
+require 'thor'
+
+module Exposition
+  class Setup < Thor
+    desc 'create_user', 'creates an admin user'
+    method_option :attributes,
+      type: :hash,
+      required: true,
+      desc: 'specifies attributes for your user account. eg. name:Johnny email:john@exposition.com password:secret password_confirmation:secret'
+    def create_user
+      user_attributes = options.fetch('attributes')
+      ::Exposition::User.create!(user_attributes)
+    end
+  end
+end

data/spec/controllers/exposition/admin/admin_controller_spec.rb

@@ -0,0 +1,88 @@
+require 'rails_helper'
+
+RSpec.describe Exposition::Admin::AdminController, type: :controller do
+  routes { Exposition::Engine.routes }
+
+  describe "#authorize" do
+    it { should use_before_action(:authorize) }
+
+    it "raises a 404 error if there is no logged in user" do
+      expect { controller.authorize }.
+        to raise_error(ActionController::RoutingError)
+    end
+
+    it "does not raise a 404 error if there is a logged in user" do
+      allow(controller).to receive(:logged_in?).and_return(true)
+
+      expect { controller.authorize }.not_to raise_error()
+    end
+  end
+
+  describe "#current_user" do
+    context "when logged in via a session" do
+      it "returns the logged in user" do
+        user = create(:user,
+                      password: 'password',
+                      email: 'j@j.com',
+                      name: 'Josh')
+        session_params = {user_id: user.id}
+        allow(controller).to receive(:session).and_return(session_params)
+
+        expect(controller.current_user).to eq(user)
+      end
+    end
+
+
+    context "when logged in via a cookie" do
+      it "returns the logged in user and sets the user_id in the session" do
+        user = create(:user,
+                      password: 'password',
+                      email: 'j@j.com',
+                      name: 'Josh')
+        user.set_encrypted_remember_token!
+        session_params = {}
+        signed_cookie_params = {user_id: user.id}
+        cookie_params = {remember_token: user.remember_token}
+        fake_cookie = FakeCookies.new(
+          signed: signed_cookie_params,
+          unsigned: cookie_params
+        )
+        allow(controller).to receive(:cookies).and_return(fake_cookie)
+        allow(controller).to receive(:session).and_return(session_params)
+
+        expect(controller.current_user).to eq(user)
+        expect(session_params[:user_id]).to eq(user.id)
+      end
+    end
+
+    describe "#logged_in?" do
+      it "returns true if current_user is present" do
+        user = double("user")
+        allow(controller).to receive(:current_user).and_return(user)
+
+        expect(controller.logged_in?).to be_truthy
+      end
+
+      it "returns false if current_user is not present" do
+        allow(controller).to receive(:current_user).and_return(nil)
+
+        expect(controller.logged_in?).to be_falsey
+      end
+    end
+
+    class FakeCookies
+      def initialize(unsigned:{}, signed:{})
+        @signed = signed
+        @unsigned = unsigned
+      end
+
+      def [](key)
+        @unsigned[key]
+      end
+
+      def signed
+        @signed
+      end
+    end
+  end
+end

data/spec/controllers/exposition/admin/posts_controller_spec.rb

@@ -0,0 +1,153 @@
+require 'rails_helper'
+
+RSpec.describe Exposition::Admin::PostsController, type: :controller do
+  routes { Exposition::Engine.routes }
+
+  before(:each) { build_user_and_login }
+
+  describe "GET #index" do
+    it "finds all the posts" do
+      blog_post = create(:post)
+
+      get :index
+
+      expect(assigns(:posts).last).to eq(blog_post)
+    end
+
+    it { paginates(factory: :post, increment: 25) { get :index } }
+  end
+
+  describe "GET #new" do
+    it "builds a new post" do
+      get :new
+
+      expect(assigns(:post)).to be_a_new(Exposition::Post)
+    end
+
+    it "finds all the users and sets them as authors" do
+      author = create(:user)
+      get :new
+
+      expect(assigns(:authors)).to eq([author])
+    end
+
+    it { finds_tags_for { get :new } }
+  end
+
+  describe "POST #create" do
+    context "with valid attributes" do
+      it "creates a new post" do
+        user = create(:user)
+        valid_post_attributes = attributes_for(:post,
+                                              title: 'Title',
+                                              body: 'Body',
+                                              author_id: user.id)
+
+        post :create, post: valid_post_attributes
+
+        expect(assigns(:post)).to be_persisted
+        expect(assigns(:post).title).to eq('Title')
+        expect(assigns(:post).body).to eq('Body')
+        expect(assigns(:post).author).to eq(user)
+        expect(flash[:success]).to eq('Post successfully created.')
+        expect(response).to redirect_to(admin_posts_path)
+      end
+    end
+
+    context "with invalid attributes" do
+      it "re-renders the new action" do
+        invalid_post_attributes = attributes_for(:post,
+                                              title: '',
+                                              body: 'Body')
+        post :create, post: invalid_post_attributes
+
+        expect(assigns(:post)).to be_a_new(Exposition::Post)
+        expect(assigns(:post).title).to eq('')
+        expect(assigns(:post).body).to eq('Body')
+        expect(response).to render_template(:new)
+      end
+    end
+
+    it "finds all the users and sets them as authors" do
+      author = create(:user)
+      post_attributes = attributes_for(:post)
+
+      post :create, post: post_attributes
+
+      expect(assigns(:authors)).to eq([author])
+    end
+
+    it { finds_tags_for { post :create, post: attributes_for(:post) } }
+  end
+
+  describe "GET #edit" do
+    it "finds the post" do
+      blog_post = create(:post)
+
+      get :edit, id: blog_post
+
+      expect(assigns(:post)).to eq(blog_post)
+    end
+
+    it "finds all the users and sets them as authors" do
+      author = create(:user)
+      post = create(:post, author: author)
+
+      get :edit, id: post
+
+      expect(assigns(:authors)).to eq([author])
+    end
+
+    it { finds_tags_for { get :edit, id: create(:post) } }
+  end
+
+  describe "GET #update" do
+    it "finds the post" do
+      blog_post = create(:post)
+
+      patch :update, id: blog_post, post: {title: 'hello'}
+
+      expect(assigns(:post)).to eq(blog_post)
+    end
+
+    it "finds all the users and sets them as authors" do
+      author = create(:user)
+      post = create(:post, author: author)
+
+      patch :update, id: post, post: {title: 'hello'}
+
+      expect(assigns(:authors)).to eq([author])
+    end
+
+    it "updates the posts attributes when given" do
+      user = create(:user)
+      blog_post = create(:post)
+
+      patch :update, id: blog_post, post: {title: "hello!",
+                                           body: "1,2,3,4",
+                                           author_id: user.id}
+
+      blog_post.reload
+
+      expect(blog_post.title).to eq("hello!")
+      expect(blog_post.body).to eq("1,2,3,4")
+      expect(blog_post.author).to eq(user)
+    end
+
+    it do
+      finds_tags_for do
+        blog_post = create(:post)
+        patch :update, id: blog_post, post: {title: 'hello'}
+      end
+    end
+  end
+
+  def finds_tags_for
+    tag = create(:tag)
+    post_attributes = attributes_for(:post)
+
+    yield
+
+    expect(assigns(:tags)).to eq([tag])
+  end
+end

data/spec/controllers/exposition/admin/sessions_controller_spec.rb

@@ -0,0 +1,46 @@
+require 'rails_helper'
+
+RSpec.describe Exposition::Admin::SessionsController, type: :controller do
+  routes { Exposition::Engine.routes }
+
+  describe "GET #new" do
+    it "returns http success" do
+      get :new
+      expect(response).to have_http_status(:success)
+    end
+  end
+
+  describe "POST #create" do
+    it "finds the user by the session email" do
+      user = create(:user, email: 'user@user.com', password: 'password')
+
+      post :create, session: {email: user.email, password: user.password}
+      expect(response).to redirect_to(admin_posts_path)
+    end
+
+    it "generates an error message with incorrect login credentials" do
+      post :create, session: {email: '', password: ''}
+
+      expect(flash[:error]).to be_present
+
+      get :new
+
+      expect(flash[:error]).to_not be_present
+    end
+  end
+
+  describe "DELETE #destroy" do
+    it "deletes the sesssion and cookies" do
+      build_user_and_login
+      session['user_id'] = 1
+      request.cookies['user_id'] = 1
+      request.cookies['remember_token'] = 'token'
+
+      delete :destroy
+
+      expect(session['user_id']).to be_nil
+      expect(cookies['user_id']).to be_nil
+      expect(cookies['remember_token']).to be_nil
+    end
+  end
+end

data/spec/controllers/exposition/admin/tags_controller_spec.rb

@@ -0,0 +1,106 @@
+require 'rails_helper'
+
+RSpec.describe Exposition::Admin::TagsController, type: :controller do
+  routes { Exposition::Engine.routes }
+
+  before(:each) { build_user_and_login }
+
+  describe "GET #index" do
+    it "finds all the tags" do
+      tag = create(:tag)
+
+      get :index
+
+      expect(assigns(:tags)).to eq([tag])
+    end
+
+    it { paginates(factory: :tag, increment: 25) { get :index } }
+  end
+
+  describe "GET #new" do
+    it "builds a new tag" do
+      get :new
+
+      expect(assigns(:tag)).to be_a_new(Categorical::Tag)
+    end
+  end
+
+  describe "POST #create" do
+    context "with valid attributes" do
+      it "creates a new tag" do
+        user = create(:user)
+        valid_tag_attributes = attributes_for(:tag, label: 'Label')
+
+        post :create, tag: valid_tag_attributes
+
+        expect(assigns(:tag)).to be_persisted
+        expect(assigns(:tag).label).to eq('Label')
+        expect(flash[:success]).to eq('Tag successfully created.')
+        expect(response).to redirect_to(admin_tags_path)
+      end
+    end
+
+    context "with invalid attributes" do
+      it "re-renders the new action" do
+        invalid_tag_attributes = attributes_for(:tag, label: '')
+        post :create, tag: invalid_tag_attributes
+
+        expect(assigns(:tag)).to be_a_new(Categorical::Tag)
+        expect(assigns(:tag).label).to eq('')
+        expect(response).to render_template(:new)
+      end
+    end
+  end
+
+  describe "GET #edit" do
+    it "finds the tag" do
+      tag = create(:tag)
+
+      get :edit, id: tag
+
+      expect(assigns(:tag)).to eq(tag)
+    end
+  end
+
+  describe "GET #update" do
+    it "finds the tag" do
+      tag = create(:tag)
+
+      patch :update, id: tag, tag: {label: 'new label'}
+
+      expect(assigns(:tag)).to eq(tag)
+    end
+
+    context "when the attributes are valid" do
+      it "updates the tags attributes when given" do
+        tag = create(:tag, label: 'old label')
+
+        patch :update, id: tag, tag: {label: "new label"}
+        tag.reload
+
+        expect(tag.label).to eq("new label")
+      end
+    end
+
+    context "when the attributes are invalid" do
+      it "renders the edit page" do
+        tag = create(:tag, label: 'old label')
+
+        patch :update, id: tag, tag: {label: ""}
+
+        expect(response).to render_template(:edit)
+      end
+    end
+  end
+
+  describe "DELETE #destroy" do
+    it "deletes the specified tag" do
+      tag = create(:tag)
+
+      delete :destroy, id: tag
+
+      expect(response).to redirect_to(admin_tags_path)
+      expect(Categorical::Tag.all).to eq([])
+    end
+  end
+end