magic_lamp 0.9.0 → 0.9.9

data/spec/lib/fixture_creator_spec.rb

@@ -1,10 +1,6 @@
 require "rails_helper"
 
 describe MagicLamp::FixtureCreator do
-  before do
-    FileUtils.rm_rf(Rails.root.join("tmp/magic_lamp"))
-  end
-
   context "attr_accessor" do
     context "render_arguments" do
       it { should respond_to :render_arguments }
@@ -23,26 +19,19 @@ describe MagicLamp::FixtureCreator do
     end
   end
 
-  describe "#create_fixture" do
-    let(:fixture_path) { Rails.root.join("tmp/magic_lamp/fixture_name.html") }
-
-    before do
-      MagicLamp.create_tmp_directory
-      subject.create_fixture("fixture_name", OrdersController) do
+  describe "#generate_template" do
+    let(:rendered) do
+      subject.generate_template(OrdersController) do
         render :foo
       end
     end
 
-    it "gives the fixture file specified name in the tmp path" do
-      expect(File.exist?(fixture_path)).to eq(true)
-    end
-
-    it "contains the template" do
-      expect(File.read(fixture_path)).to eq("foo\n")
+    it "returns the template as a string" do
+      expect(rendered).to eq("foo\n")
     end
 
     it "does not render the layout by default" do
-      expect(File.read(fixture_path)).to_not match(/The layout/)
+      expect(rendered).to_not match(/The layout/)
     end
   end
 

data/spec/lib/magic_lamp_spec.rb

@@ -1,98 +1,185 @@
 require "rails_helper"
 
 describe MagicLamp do
+  before do
+    subject.registered_fixtures = {}
+  end
 
-  describe "#path" do
-    context "spec directory" do
-      let(:spec_path) { Rails.root.join("spec") }
+  after do
+    subject.registered_fixtures = {}
+  end
 
-      it "returns a default path starting from spec" do
-        expect(subject.path).to eq(spec_path)
-      end
-    end
+  context "attr_accessor" do
+    it { should respond_to :registered_fixtures }
+    it { should respond_to :registered_fixtures= }
+  end
 
-    context "no spec directory" do
-      let(:test_path) { Rails.root.join("test") }
+  context "aliases" do
+    let(:register_fixture) { subject.method(:register_fixture) }
 
-      it "returns a default path starting from test" do
-        allow(Dir).to receive(:exist?).and_return(false)
-        expect(subject.path).to eq(test_path)
-      end
+    it "rub is the same as register_fixture" do
+      expect(subject.method(:rub)).to eq(register_fixture)
+    end
+
+    it "wish is the same as register_fixture" do
+      expect(subject.method(:wish)).to eq(register_fixture)
     end
   end
 
-  describe "#tmp_path" do
-    let(:tmp_path) { Rails.root.join("tmp/magic_lamp") }
+  describe "#register_fixture" do
+    let(:fixture_name) { "foo" }
+    let(:controller_class) { "doesn't matter here" }
+    let(:block) { Proc.new { "so?" } }
+
+    it "caches the controller class and block" do
+      subject.register_fixture(controller_class, fixture_name, &block)
+      expect(subject.registered_fixtures[fixture_name]).to eq([controller_class, block])
+    end
+
+    it "raises an error without a block" do
+      expect do
+        subject.register_fixture(controller_class, fixture_name)
+      end.to raise_error(ArgumentError, /requires a block/)
+    end
 
-    it "returns the path to tmp" do
-      expect(subject.tmp_path).to eq(tmp_path)
+    context "defaults" do
+      let(:at_index) { subject.registered_fixtures["index"] }
+
+      it "uses ApplicationController as the default controller" do
+        subject.register_fixture { render :index }
+        expect(at_index.first).to eq(::ApplicationController)
+      end
+
+      context "fixture name" do
+        it "raises an error if the fixture is already registered by that name" do
+          subject.register_fixture { render :index }
+          expect do
+            subject.register_fixture { render :index }
+          end.to raise_error(MagicLamp::AlreadyRegisteredFixtureError, "a fixture called 'index' has already been registered")
+        end
+
+        context "ApplicationController" do
+          it "uses the first argument to render when given 2" do
+            render_block = Proc.new { render :index, foo: :bar }
+            subject.register_fixture(::ApplicationController, &render_block)
+
+            expect(at_index).to eq([::ApplicationController, render_block])
+          end
+
+          it "uses the only argument when it isn't a hash" do
+            render_block = Proc.new { render :index }
+            subject.register_fixture(::ApplicationController, &render_block)
+            expect(at_index).to eq([::ApplicationController, render_block])
+          end
+
+          context "1 hash argument" do
+            it "raises an error if it can't figure out a default name" do
+              expect do
+                subject.register_fixture(::ApplicationController) { render collection: [1, 2, 3] }
+              end.to raise_error(MagicLamp::AmbiguousFixtureNameError, /Unable to infer fixture name/)
+            end
+
+            it "uses the name at the template key" do
+              render_block = Proc.new { render template: :index }
+              subject.register_fixture(::ApplicationController, &render_block)
+              expect(at_index).to eq([::ApplicationController, render_block])
+            end
+
+            it "uses the name at the partial key" do
+              render_block = Proc.new { render partial: :index }
+              subject.register_fixture(::ApplicationController, &render_block)
+              expect(at_index).to eq([::ApplicationController, render_block])
+            end
+          end
+        end
+
+        context "other controller" do
+          it "prepends the controller's name to the fixture_name" do
+            render_block = Proc.new { render partial: :index }
+            subject.register_fixture(OrdersController, &render_block)
+            expect(subject.registered_fixtures["orders/index"]).to eq([OrdersController, render_block])
+          end
+        end
+      end
     end
   end
 
-  describe "#create_tmp_directory" do
-    let(:tmp_directory) { subject.tmp_path }
+  describe "#load_lamp_files" do
+    it "loads all lamp files" do
+      subject.load_lamp_files
+      expect(subject.registered_fixtures["orders/foo"]).to be_an(Array)
+    end
+
+    it "blows out registered_fixtures on each call" do
+      old_registry = subject.registered_fixtures
+      subject.load_lamp_files
+      expect(subject.registered_fixtures).to_not equal(old_registry)
 
-    before do
-      subject.create_tmp_directory
+      old_registry = subject.registered_fixtures
+      subject.load_lamp_files
+      expect(subject.registered_fixtures).to_not equal(old_registry)
     end
+  end
 
-    it "creates the magic lamp tmp directory" do
-      expect(File.exist?(tmp_directory)).to eq(true)
+  describe "#registered?" do
+
+    it "returns true if the fixture is registered" do
+      subject.registered_fixtures["foo"] = :something
+      expect(subject.registered?("foo")).to eq(true)
     end
 
-    it "doesn't throw an error when the directory already exists" do
-      expect do
-        subject.create_tmp_directory
-      end.to_not raise_error
+    it "returns false if the fixture is not registered" do
+      expect(subject.registered?("bar")).to eq(false)
     end
   end
 
-  describe "#remove_tmp_directory" do
-    let(:tmp_directory) { subject.tmp_path }
+  describe "#generate_fixture" do
+    let(:block) { Proc.new { render :foo } }
 
     before do
-      subject.create_tmp_directory
-      subject.remove_tmp_directory
+      subject.registered_fixtures["foo_test"] = [OrdersController, block]
     end
 
-    it "removes the magic lamp tmp directory" do
-      expect(File.exist?(tmp_directory)).to eq(false)
+    it "returns the template" do
+      expect(subject.generate_fixture("foo_test")).to eq("foo\n")
     end
 
-    it "doesn't throw an error when the directory doesn't exist before deletion" do
+    it "raises an error when told to generate a template that is not registered" do
       expect do
-        subject.remove_tmp_directory
-      end.to_not raise_error
+        subject.generate_fixture("brokenture")
+      end.to raise_error(MagicLamp::UnregisteredFixtureError, /is not a registered fixture/)
     end
   end
 
-  describe "#create_fixture" do
+  describe "#generate_all_fixtures" do
+    let!(:result) { subject.generate_all_fixtures }
+    let(:foo_fixture) { result["orders/foo"] }
+    let(:bar_fixture) { result["orders/bar"] }
+    let(:form_fixture) { result["orders/form"] }
 
-    it "passes through its arguments and block to an instance of FixtureCreator" do
-      passed_block = Proc.new { render :foo }
-      fixture_creator = MagicLamp::FixtureCreator.new
-      allow(MagicLamp::FixtureCreator).to receive(:new).and_return(fixture_creator)
-
-      expect(fixture_creator).to receive(:create_fixture) do |fixture_name, controller_class, &block|
-        expect(fixture_name).to eq("foo")
-        expect(controller_class).to eq(OrdersController)
-        expect(block).to eq(passed_block)
-      end
-
-      subject.create_fixture("foo", OrdersController, &passed_block)
+    it "returns a hash of all registered fixtures" do
+      expect(foo_fixture).to eq("foo\n")
+      expect(bar_fixture).to eq("bar\n")
+      expect(form_fixture).to match(/<div class="actions"/)
     end
   end
 
-  describe "#load_lamp_files" do
+  describe "#path" do
+    context "spec directory" do
+      let(:spec_path) { Rails.root.join("spec") }
 
-    it "calls create_tmp_directory" do
-      expect(subject).to receive(:create_tmp_directory).and_call_original
-      subject.load_lamp_files
+      it "returns a default path starting from spec" do
+        expect(subject.path).to eq(spec_path)
+      end
     end
 
-    it "loads all _lamp files in the specified path" do
-      subject.load_lamp_files
-      expect(subject.instance_eval("@foo")).to eq("from lamp file")
+    context "no spec directory" do
+      let(:test_path) { Rails.root.join("test") }
+
+      it "returns a default path starting from test" do
+        allow(Dir).to receive(:exist?).and_return(false)
+        expect(subject.path).to eq(test_path)
+      end
     end
   end
 end

data/spec/lib/render_catcher_spec.rb

@@ -0,0 +1,35 @@
+require "rails_helper"
+
+describe RenderCatcher do
+
+  context "attr_accessor" do
+    it { should respond_to :render_argument }
+    it { should respond_to :render_argument= }
+  end
+
+  describe "#render" do
+    it "saves its first arguments as render argument" do
+      subject.render :foo, :bar, :baz
+      expect(subject.render_argument).to eq(:foo)
+    end
+  end
+
+  describe "#first_render_argument" do
+    let(:block) { Proc.new { render :foo, :bar, :baz } }
+    let(:result) { subject.first_render_argument(&block) }
+
+    it "returns the first argument to render given a block" do
+      expect(result).to eq(:foo)
+    end
+  end
+
+  describe "#method_missing" do
+    it "does nothing when an unknown method is called" do
+      expect do
+        subject.foo
+        subject.foo = "what"
+        subject.bar(1, 2, 3) { |x| "never gonna happen" }
+      end.to_not raise_error
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -1,7 +1,7 @@
-# This file is copied to spec/ when you run "rails generate rspec:install"
+# This file is copied to spec/ when you run 'rails generate rspec:install'
 ENV["RAILS_ENV"] ||= "test"
 require "spec_helper"
-require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require File.expand_path("../dummy/config/environment", __FILE__)
 require "rspec/rails"
 
 # Requires supporting ruby files with custom matchers and macros, etc, in
@@ -9,7 +9,7 @@ require "rspec/rails"
 # run as spec files by default. This means that files in spec/support that end
 # in _spec.rb will both be required and run as specs, causing the specs to be
 # run twice. It is recommended that you do not name files matching this glob to
-# end with _spec.rb. You can configure this pattern with with the --pattern
+# end with _spec.rb. You can configure this pattern with the --pattern
 # option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
 Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f }
 
@@ -17,8 +17,6 @@ Dir[Rails.root.join("spec/support/**/*.rb")].each { |f| require f }
 # If you are not using ActiveRecord, you can remove this line.
 ActiveRecord::Migration.maintain_test_schema!
 
-Rails.application.load_tasks
-
 RSpec.configure do |config|
   # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
   config.fixture_path = "#{::Rails.root}/spec/fixtures"
@@ -42,12 +40,4 @@ RSpec.configure do |config|
   # The different available types are documented in the features, such as in
   # https://relishapp.com/rspec/rspec-rails/docs
   config.infer_spec_type_from_file_location!
-
-  config.before(:suite) do
-    FileUtils.rm_rf(Rails.root.join("tmp/magic_lamp"))
-  end
-
-  config.after(:suite) do
-    FileUtils.rm_rf(Rails.root.join("tmp/magic_lamp"))
-  end
 end

data/spec/spec_helper.rb

@@ -23,7 +23,6 @@ RSpec.configure do |config|
   # `:focus` metadata. When nothing is tagged with `:focus`, all examples
   # get run.
   config.filter_run :focus
-  config.filter_run_excluding :integration
   config.run_all_when_everything_filtered = true
 
   # Many RSpec users commonly either run the entire suite or an individual
@@ -33,13 +32,13 @@ RSpec.configure do |config|
     # 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"
+    config.default_formatter = "progress"
   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 = 2
+  # 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

data/spec/teaspoon_env.rb

@@ -0,0 +1,186 @@
+# Set RAILS_ROOT and load the environment if it's not already loaded.
+unless defined?(Rails)
+  ENV["RAILS_ROOT"] = File.expand_path("../dummy/", __FILE__)
+  require File.expand_path("../dummy/config/environment", __FILE__)
+end
+
+Teaspoon.configure do |config|
+  # Determines where the Teaspoon routes will be mounted. Changing this to "/jasmine" would allow you to browse to
+  # `http://localhost:3000/jasmine` to run your tests.
+  #config.mount_at = "/teaspoon"
+
+  # Specifies the root where Teaspoon will look for files. If you're testing an engine using a dummy application it can
+  # be useful to set this to your engines root (e.g. `Teaspoon::Engine.root`).
+  # Note: Defaults to `Rails.root` if nil.
+  #config.root = nil
+  config.root = MagicLamp::Engine.root
+
+  # Paths that will be appended to the Rails assets paths
+  # Note: Relative to `config.root`.
+  #config.asset_paths = ["spec/javascripts", "spec/javascripts/stylesheets"]
+  config.asset_paths << MagicLamp::Engine.root.join("lib/magic_lamp")
+
+  config.driver = "selenium"
+  config.driver_options = { client_driver: :chrome }
+
+  # Fixtures are rendered through a controller, which allows using HAML, RABL/JBuilder, etc. Files in these paths will
+  # be rendered as fixtures.
+  #config.fixture_paths = ["spec/javascripts/fixtures"]
+
+  # SUITES
+  #
+  # You can modify the default suite configuration and create new suites here. Suites are isolated from one another.
+  #
+  # When defining a suite you can provide a name and a block. If the name is left blank, :default is assumed. You can
+  # omit various directives and the ones defined in the default suite will be used.
+  #
+  # To run a specific suite
+  # - in the browser: http://localhost/teaspoon/[suite_name]
+  # - with the rake task: rake teaspoon suite=[suite_name]
+  # - with the cli: teaspoon --suite=[suite_name]
+  config.suite do |suite|
+
+    # Specify the framework you would like to use. This allows you to select versions, and will do some basic setup for
+    # you -- which you can override with the directives below. This should be specified first, as it can override other
+    # directives.
+    # Note: If no version is specified, the latest is assumed.
+    #
+    # Available: jasmine[1.3.1, 2.0.0], mocha[1.10.0, 1.17.1] qunit[1.12.0, 1.14.0]
+    suite.use_framework :mocha, "1.17.1"
+
+    # Specify a file matcher as a regular expression and all matching files will be loaded when the suite is run. These
+    # files need to be within an asset path. You can add asset paths using the `config.asset_paths`.
+    #suite.matcher = "{spec/javascripts,app/assets}/**/*_spec.{js,js.coffee,coffee}"
+
+    # This suites spec helper, which can require additional support files. This file is loaded before any of your test
+    # files are loaded.
+    #suite.helper = "spec_helper"
+
+    # The core Teaspoon javascripts. It's recommended to include only the base files here, as you can require support
+    # libraries from your spec helper.
+    # Note: For CoffeeScript files use `"teaspoon/jasmine"` etc.
+    #
+    # Available: teaspoon-jasmine, teaspoon-mocha, teaspoon-qunit
+    #suite.javascripts = ["mocha/1.17.1", "teaspoon-mocha"]
+
+    # You can include your own stylesheets if you want to change how Teaspoon looks.
+    # Note: Spec related CSS can and should be loaded using fixtures.
+    #suite.stylesheets = ["teaspoon"]
+
+    # Partial to be rendered in the head tag of the runner. You can use the provided ones or define your own by creating
+    # a `_boot.html.erb` in your fixtures path, and adjust the config to `"/boot"` for instance.
+    #
+    # Available: boot, boot_require_js
+    #suite.boot_partial = "boot"
+
+    # Partial to be rendered in the body tag of the runner. You can define your own to create a custom body structure.
+    #suite.body_partial = "body"
+
+    # Assets to be ignored when generating coverage reports. Accepts an array of filenames or regular expressions. The
+    # default excludes assets from vendor, gems and support libraries.<br/><br/>
+    #suite.no_coverage = [%r{/lib/ruby/gems/}, %r{/vendor/assets/}, %r{/support/}, %r{/(.+)_helper.}]
+
+    # Hooks allow you to use `Teaspoon.hook("fixtures")` before, after, or during your spec run. This will make a
+    # synchronous Ajax request to the server that will call all of the blocks you've defined for that hook name.
+    #suite.hook :fixtures, proc{ }
+
+  end
+
+  # Example suite. Since we're just filtering to files already within the root test/javascripts, these files will also
+  # be run in the default suite -- but can be focused into a more specific suite.
+  #config.suite :targeted do |suite|
+  #  suite.matcher = "test/javascripts/targeted/*_test.{js,js.coffee,coffee}"
+  #end
+
+  # CONSOLE RUNNER SPECIFIC
+  #
+  # These configuration directives are applicable only when running via the rake task or command line interface. These
+  # directives can be overridden using the command line interface arguments or with ENV variables when using the rake
+  # task.
+  #
+  # Command Line Interface:
+  # teaspoon --driver=phantomjs --server-port=31337 --fail-fast=true --format=junit --suite=my_suite /spec/file_spec.js
+  #
+  # Rake:
+  # teaspoon DRIVER=phantomjs SERVER_PORT=31337 FAIL_FAST=true FORMATTERS=junit suite=my_suite
+
+  # Specify which headless driver to use. Supports PhantomJS and Selenium Webdriver.
+  #
+  # Available: phantomjs, selenium
+  # PhantomJS: https://github.com/modeset/teaspoon/wiki/Using-PhantomJS
+  # Selenium Webdriver: https://github.com/modeset/teaspoon/wiki/Using-Selenium-WebDriver
+  #config.driver = "phantomjs"
+
+  # Specify additional options for the driver.
+  #
+  # PhantomJS: https://github.com/modeset/teaspoon/wiki/Using-PhantomJS
+  # Selenium Webdriver: https://github.com/modeset/teaspoon/wiki/Using-Selenium-WebDriver
+  #config.driver_options = nil
+
+  # Specify the timeout for the driver. Specs are expected to complete within this time frame or the run will be
+  # considered a failure. This is to avoid issues that can arise where tests stall.
+  #config.driver_timeout = 180
+
+  # Specify a server to use with Rack (e.g. thin, mongrel). If nil is provided Rack::Server is used.
+  #config.server = nil
+
+  # Specify a port to run on a specific port, otherwise Teaspoon will use a random available port.
+  #config.server_port = nil
+
+  # Timeout for starting the server in seconds. If your server is slow to start you may have to bump this, or you may
+  # want to lower this if you know it shouldn't take long to start.
+  #config.server_timeout = 20
+
+  # Force Teaspoon to fail immediately after a failing suite. Can be useful to make Teaspoon fail early if you have
+  # several suites, but in environments like CI this may not be desirable.
+  #config.fail_fast = true
+
+  # Specify the formatters to use when outputting the results.
+  # Note: Output files can be specified by using `"junit>/path/to/output.xml"`.
+  #
+  # Available: dot, documentation, clean, json, junit, pride, snowday, swayze_or_oprah, tap, tap_y, teamcity
+  #config.formatters = ["dot"]
+
+  # Specify if you want color output from the formatters.
+  #config.color = true
+
+  # Teaspoon pipes all console[log/debug/error] to $stdout. This is useful to catch places where you've forgotten to
+  # remove them, but in verbose applications this may not be desirable.
+  #config.suppress_log = false
+
+  # COVERAGE REPORTS / THRESHOLD ASSERTIONS
+  #
+  # Coverage reports requires Istanbul (https://github.com/gotwarlost/istanbul) to add instrumentation to your code and
+  # display coverage statistics.
+  #
+  # Coverage configurations are similar to suites. You can define several, and use different ones under different
+  # conditions.
+  #
+  # To run with a specific coverage configuration
+  # - with the rake task: rake teaspoon USE_COVERAGE=[coverage_name]
+  # - with the cli: teaspoon --coverage=[coverage_name]
+
+  # Specify that you always want a coverage configuration to be used.
+  #config.use_coverage = nil
+
+  config.coverage do |coverage|
+
+    # Which coverage reports Instanbul should generate. Correlates directly to what Istanbul supports.
+    #
+    # Available: text-summary, text, html, lcov, lcovonly, cobertura, teamcity
+    #coverage.reports = ["text-summary", "html"]
+
+    # The path that the coverage should be written to - when there's an artifact to write to disk.
+    # Note: Relative to `config.root`.
+    #coverage.output_dir = "coverage"
+
+    # Various thresholds requirements can be defined, and those thresholds will be checked at the end of a run. If any
+    # aren't met the run will fail with a message. Thresholds can be defined as a percentage (0-100), or nil.
+    #coverage.statements = nil
+    #coverage.functions = nil
+    #coverage.branches = nil
+    #coverage.lines = nil
+
+  end
+
+end