active-fixtures 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 54bd0172edecb818492c68d1ee90d4c6c3fc855c
+  data.tar.gz: ba2b97ec7dc4c14a95765dfd98dc56e0e85cb017
+SHA512:
+  metadata.gz: c41606271c058aa0e688c1aba385054eac7e68609d44ef8f8ebddba15caaf6755a7b1b57b33c848ff9c78a1b7f2938c4521f5560d0677a33387b91b49dfb90f3
+  data.tar.gz: 735065ee98e5e34df977c6a607067ea0465b611d89850534195ffdc94f15260cf63b70cca75ede71996d7b1ab85141d893baf5417de1a738e6c68cbdf619884c

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sergey Tokarenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,175 @@
+ActiveFixtures
+==============
+[![Version](https://badge.fury.io/rb/active-fixtures.svg)](http://badge.fury.io/rb/active-fixtures)
+
+ActiveFixtures provides the way how to populate the server state (DB, sessions) as an application user but not as programmer.
+
+## Why?
+The correct question is `why we write the tests at all?`.
+Or even better - `what does the green line means?`.
+
+Typical legacy code contains a tons of tests in isolation aka Unit Tests.
+Mocks, stubs, factories & terrible traits, fakers etc etc.
+Many smart things, so called `best practices`, a lot of efforts and time spent to write all of these.
+
+And, after all - application just can't run due to the simple misspelling in `routes.rb`.
+
+So, what is a really valuable reason to write the tests?
+
+We working on the project for somebody personal.
+We creating the web application for web users, we write the new cool library for other programmers.
+The primary goal of automatic tests is to be sure that `our code works right like the target user expects`.
+
+Test web application as web user plays with it.
+Test the public methods of your library just like other programmer will use them.
+Test web service endpoints just like the third-party applications will call them.
+
+Nobody interested how exactly working the private methods in `Product` class.
+Even more, nobody interested to know that class `Product` exists, it mapped to some database table etc.
+
+Single thing is matter - how the application's user thinking about your application,
+which entities he understand, how he affects to such entities.
+
+In general case, tests in isolation are at least useless, at max - hurtful.
+Lets write acceptance tests instead!
+
+## requirements
+Currently works with Poltergeist and PostgreSQL.
+
+## Getting started
+
+Add to your Gemfile:
+
+```ruby
+gem 'ruby-features', group: :test
+```
+
+Add to your rspec helper:
+```ruby
+require 'active-fixtures/rspec'
+```
+
+Remove Database Cleaners from your project, ActiveFixtures will take care about database cleanup in additional.
+
+## Usage
+### Active factory definition
+Lets add the active factory in `spec/active_fixtures/user.rb`:
+
+```ruby
+class AFUser < ActiveFixtures::Resource
+  attribute :login, type: String, default: 'admin@lvh.me'
+  attribute :password, type: String, default: 'p@ssw0rd'
+
+  def self.create_initial(attrs = {})
+    new(attrs).tap { |user|
+      Rake::Task['user:create'].invoke(user.login, user.password)
+      Rake::Task['user:create'].reenable
+    }
+  end
+
+  def self.create(attrs = {})
+    new(attrs).tap { |user|
+      af_session(:admin) do
+        click_on 'Admins'
+
+        click_on 'Invite'
+        fill_in 'Email', with: user.login
+        click_on 'Send an invitation'
+      end
+
+      af_session do
+        open_email(user.login)
+
+        current_email.click_on 'Accept invitation'
+        fill_in 'Password', with: user.password
+        fill_in 'Password confirmation', with: user.password
+        click_on 'Set my password'
+        assert_text 'Your password was set successfully. You are now signed in.'
+      end
+    }
+  end
+
+  def sign_in
+    visit '/'
+    fill_in 'Email', with: login
+    fill_in 'Password', with: password
+    click_on 'Sign in'
+    assert_text 'Signed in successfully.'
+  end
+
+end
+```
+
+Implement the resource factory just like the application user will do -
+capybara steps, rake tasks invocation, API calls etc.
+
+Any methods available in `it` rspec context will be available in the factory
+(for example `open_email` helper from `capybara-email` gem).
+
+`ActiveFixtures::Resource` includes the [ActiveAttr::Model](https://github.com/cgriego/active_attr),
+feel free to use any it's features.
+
+`af_session` helper called without parameter will provide the clean capybara session on each call.
+Use it in factory to avoid the influence to rspec's example default session.
+
+`af_session` with parameter is a bit tricky, lets recall it later.
+
+Now you can use factory in your tests:
+```ruby
+describe 'Users' do
+  let(:admin) { AFUser.create_initial }
+
+  it 'should pass' do
+    admin.sing_in
+  end
+end
+```
+
+### Fixtures definition
+Lets define active fixture in `spec/active_fixtures/_fixtures.rb`:
+
+```ruby
+ActiveFixtures.populate(:default) do
+  resource(:admin) { AFUser.create_initial }
+  session(:admin) { AFUser[:admin].sign_in }
+  resource(:invited_admin) { AFUser.create(login: 'new_user@lvh.me') }
+end
+```
+
+`:default` fixture will be loaded before each rspec example. You can play with resources like that:
+```ruby
+it 'should pass' do
+  AFUser[:invited_admin].sign_in
+end
+```
+
+### Active sessions
+Once you defined the named session in factory, you can use it by `af_session` helper:
+```ruby
+it 'should pass' do
+  af_session(:admin) do
+    # already logged as admin
+  end
+
+  # some code
+  af_session(:admin) do
+    # second and any further `af_session` call within the same example
+    # will drop the session to the state reached right after the session initialization
+    # - same current URL, same cookies. This way you don't need to keep in mind
+    # what you did with named session before, but can expect the same session state each time.
+  end
+
+  af_session do
+    # always clean session, with blank current URL
+  end
+end
+```
+
+### How it works
+ActiveFixtures work fairly, but effectively.
+
+Fixture will be populated on the first it's usage, by genuine application's user actions.
+For the next example it will be loaded from cache - no sense to to the same work again.
+
+## License
+MIT License. Copyright (c) 2016 Sergey Tokarenko

data/lib/active-fixtures.rb

@@ -0,0 +1,45 @@
+require 'active-fixtures/version'
+
+module ActiveFixtures
+  autoload :Resource, 'active-fixtures/resource'
+
+  autoload :Session, 'active-fixtures/session'
+  autoload :StateBuilder, 'active-fixtures/state_builder'
+  autoload :State, 'active-fixtures/state'
+  autoload :StateDumper, 'active-fixtures/state_dumper'
+
+  mattr_accessor :state_builders
+  self.state_builders = {}
+
+  class << self
+    def populate(name, &block)
+      state_builders[name] = StateBuilder.new(block)
+    end
+
+    def init!
+      StateDumper.init!
+    end
+
+    def cleanup!
+      StateDumper.cleanup!
+    end
+
+    def prepare!(name)
+      self.current_state = State.new(name)
+      current_state.prepare!(state_builders[name])
+    end
+
+    def thread_storage
+      Thread.current[:__active_fixtures] ||= {}
+    end
+
+    def current_state
+      thread_storage[:current_state]
+    end
+
+    def current_state=(state)
+      thread_storage[:current_state] = state
+    end
+
+  end
+end

data/lib/active-fixtures/resource.rb

@@ -0,0 +1,25 @@
+module ActiveFixtures
+  class Resource
+    include ActiveAttr::Model
+
+    delegate :context, to: :class
+
+    def self.[](name)
+      ActiveFixtures.current_state.read_entity(name, self)
+    end
+
+    private
+
+    def self.context
+      RSpec.current_example.example_group_instance
+    end
+
+    def self.method_missing(method, *args, &block)
+      context.respond_to?(method) ?
+        context.public_send(method, *args, &block) :
+        super
+    end
+
+    define_method(:method_missing, &method(:method_missing))
+  end
+end

data/lib/active-fixtures/rspec.rb

@@ -0,0 +1,19 @@
+Dir[Rails.root.join('spec/active_fixtures/**/*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  config.include ActiveFixtures::Session::Helper
+
+  config.around(:each) do |example|
+    ActiveFixtures.prepare!(:default)
+    example.run
+  end
+
+  config.before(:suite) do
+    ActiveFixtures.init!
+  end
+
+  config.after(:suite) do
+    ActiveFixtures.cleanup!
+  end
+
+end

data/lib/active-fixtures/session.rb

@@ -0,0 +1,51 @@
+module ActiveFixtures
+  class Session < Resource
+    CLEAN_NAME = :__clean
+
+    module Helper
+      def af_session(name = CLEAN_NAME, &block)
+        Session[name].perform(block)
+      end
+    end
+
+    attribute :name, type: String, default: CLEAN_NAME
+    attribute :url, type: String
+    attribute :cookies, type: Object, default: []
+
+    def initialize(attrs = {})
+      super
+
+      cookies.map!(&:symbolize_keys!)
+
+      if attrs[:block]
+        using_session do
+          attrs[:block].call
+
+          self.url = context.current_url
+          self.cookies = context.page.driver.cookies.values.map{ |c| c.instance_variable_get(:@attributes).symbolize_keys}
+        end
+      end
+    end
+
+    def perform(block)
+      res = nil
+
+      using_session do
+        context.reset_session!
+        cookies.each do |cookie|
+          context.page.driver.set_cookie(nil, nil, cookie)
+        end
+        context.visit(url) if url
+        res = block.call
+      end
+
+      res
+    end
+
+    private
+
+    def using_session(&block)
+      context.using_session("__af::#{name}", &block)
+    end
+  end
+end

data/lib/active-fixtures/state.rb

@@ -0,0 +1,47 @@
+module ActiveFixtures
+  class State
+    attr_accessor :name
+
+    def initialize(_name)
+      self.name = _name
+    end
+
+    def prepare!(state_builder)
+      entities.clear
+
+      if StateDumper.exists?(name)
+        entities.merge!(StateDumper.load(name))
+      else
+        StateDumper.load_clean
+
+        clean_session = Session.new
+        write_entity(clean_session.name, clean_session)
+
+        state_builder.prepare_each do |name, resource|
+          write_entity(name, resource)
+        end
+
+        StateDumper.dump(self)
+      end
+    end
+
+    def read_entity(name, resource_class)
+      entities[normalize_name(name, resource_class)]
+    end
+
+    def entities
+      ActiveFixtures.thread_storage[:entities] ||= {}
+    end
+
+    private
+
+    def write_entity(name, resource)
+      entities[normalize_name(name, resource.class)] = resource
+    end
+
+    def normalize_name(name, resource_class)
+      "#{resource_class.name}::#{name}"
+    end
+
+  end
+end

data/lib/active-fixtures/state_builder.rb

@@ -0,0 +1,37 @@
+module ActiveFixtures
+  class StateBuilder
+    attr_accessor :steps
+
+    def initialize(block)
+      self.steps = []
+      instance_eval(&block)
+    end
+
+    def prepare_each
+      steps.each do |build_step|
+        yield(
+          build_step[:name],
+          send("build_#{build_step[:type]}", build_step)
+        )
+      end
+    end
+
+    private
+
+    def resource(name, &block)
+      steps << {type: :resource, name: name, block: block}
+    end
+
+    def session(name, &block)
+      steps << {type: :session, name: name, block: block}
+    end
+
+    def build_resource(build_step)
+      build_step[:block].call
+    end
+
+    def build_session(build_step)
+      Session.new(build_step)
+    end
+  end
+end

data/lib/active-fixtures/state_dumper.rb

@@ -0,0 +1,67 @@
+module ActiveFixtures
+  module StateDumper
+    FIXTURES_PATH = Rails.root.join('spec/fixtures/active').freeze
+    DB_NAME = ApplicationRecord.connection_config[:database].freeze
+    CLEAN_STATE_NAME = :__clean
+
+    class << self
+      def init!
+        FileUtils.mkdir_p(FIXTURES_PATH)
+        dump_db(CLEAN_STATE_NAME)
+      end
+
+      def cleanup!
+        load_clean
+        FileUtils.rm_rf(FIXTURES_PATH) if File.exist?(FIXTURES_PATH)
+      end
+
+      def exists?(state_name)
+        File.exists?(dump_db_file(state_name))
+      end
+
+      def load_clean
+        load_db(CLEAN_STATE_NAME)
+      end
+
+      def load(state_name)
+        load_db(state_name)
+
+        Hash[*JSON.parse(File.read(dump_entities_file(state_name))).flat_map{ |name, attrs|
+          [name, name.gsub(/::[^:]*\z/, '').constantize.new(attrs)]
+        }]
+      end
+
+      def dump(state)
+        dump_db(state.name)
+        File.write(
+          dump_entities_file(state.name),
+          Hash[*state.entities.flat_map{ |name, entity|
+            [name, entity.attributes]
+          }].to_json
+        )
+      end
+
+      private
+
+      def dump_db_file(state_name)
+        File.join(FIXTURES_PATH, "#{state_name}.db.dump")
+      end
+
+      def dump_entities_file(state_name)
+        File.join(FIXTURES_PATH, "#{state_name}.entities.json")
+      end
+
+      def dump_db(state_name)
+        args = ['-x', '-O', '-c', '-Fc', '-f', dump_db_file(state_name), DB_NAME]
+        Kernel.system('pg_dump', *args)
+      end
+
+      def load_db(state_name)
+        args = ['-c', '-d', DB_NAME, dump_db_file(state_name)]
+        Kernel.system('pg_restore', *args)
+      end
+
+    end
+
+  end
+end

data/lib/active-fixtures/version.rb

@@ -0,0 +1,3 @@
+module ActiveFixtures
+  VERSION = '0.0.1'.freeze
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: active-fixtures
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sergey Tokarenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-05 00:00:00.000000000 Z
+dependencies: []
+description: active-fixtures provides the way how to populate the server state (DB,
+  sessions) as an application user but not as programmer.
+email: private.tokarenko.sergey@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/active-fixtures.rb
+- lib/active-fixtures/resource.rb
+- lib/active-fixtures/rspec.rb
+- lib/active-fixtures/session.rb
+- lib/active-fixtures/state.rb
+- lib/active-fixtures/state_builder.rb
+- lib/active-fixtures/state_dumper.rb
+- lib/active-fixtures/version.rb
+homepage: https://github.com/Anadea/active-fixtures
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: active-fixtures provides the way how to populate the server state (DB, sessions)
+  as an application user but not as programmer.
+test_files: []