tset 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f27830bfa45780af901203d61a7fc1b52dc906dd
+  data.tar.gz: 73e19fa5e554d5ee50f6737bc05dbad47e077d43
+SHA512:
+  metadata.gz: cf6b9261c29093169b72eb15291375d5fbce2e9190c9d163b10a6c71bee4137301d9609f8b6bab82a75036e9270508875c29375bc29befda0cb09677e56e0f70
+  data.tar.gz: 650a7258cad0b33de4f6df0075e2142dcea56e056d648d6d0d224881127e91bd8c3482b3236c4e387e1ad7c2a1a39b90449af5ca7cd28bf30fd7b114ab21315e

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--format documentation

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'byebug', require: false
+
+# Specify your gem's dependencies in tset.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Sung Won Cho
+
+MIT License
+
+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,49 @@
+# Tset
+
+Tset generates tests for your models in your Rails application.
+
+## Why?
+
+TDD is great, but sometimes you just want to write some codes.
+
+Enter 'Development Driven Test'. Tset enables you to just write codes and worry about tests later.
+
+## Installation
+
+Run installation command.
+
+```
+gem install tset
+```
+
+OR if you are using bundler,
+
+```ruby
+gem 'tset', group: :development
+```
+
+Run `bundle`
+
+## Usage
+
+In your application root directory, run the generator.
+
+```
+tset generate model YOUR_MODEL_NAME
+```
+
+Tset will read your model and generate a test accordingly.
+
+By default, the Tset will use RSpec. Help us add MiniTest support by contributing.
+
+## Fact
+
+* Tset is a test spelled backwards.
+
+## Contributing
+
+### TODO
+
+* Help us improve Tset by adding more test rules located in translators.
+* Support MiniTest.
+* Support controllers.

data/Rakefile

@@ -0,0 +1,6 @@
+require "rspec/core/rake_task"
+require "bundler/gem_tasks"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/tset

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "tset/cli"
+Tset::Cli.start

data/lib/tset/analyzers/abstract.rb

@@ -0,0 +1,15 @@
+module Tset
+  module Analyzers
+    #
+    # Abstract superclass for analyzers
+    #
+    # @abstract
+    #
+    class Abstract
+
+      def start
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/tset/analyzers/action.rb

@@ -0,0 +1,17 @@
+#
+# Representation of action and its content in a controller
+#
+# @param name [String] a name of an action
+# @param body [String] a content of an action
+#
+module Tset
+  module Analyzers
+    class Action
+
+      def initialize(name, body)
+        @name = name
+        @body = body
+      end
+    end
+  end
+end

data/lib/tset/analyzers/model.rb

@@ -0,0 +1,56 @@
+require "tset/analyzers/abstract"
+require "tset/translators/rspec"
+require "tset/testable"
+require "pathname"
+
+# Reads the model file and breaks it down into an array of testables.
+#
+# @param name [String] the name of the model
+# @return [Array] the model codes for which tests can be generated.
+#
+module Tset
+  module Analyzers
+    class Model < Abstract
+
+      attr_reader :name, :target
+
+      def initialize(name)
+        @name = name
+        @target = Pathname.pwd.join('app/models')
+      end
+
+      def start
+        detect_testable_lines
+      end
+
+      private
+
+      def detect_testable_lines
+        testable_lines = []
+
+        content = _model_file.read
+
+        testable_patterns.each do |pattern|
+          testable_lines << content.each_line.grep(pattern) do |matching_line|
+            Tset::Testable.new('model', matching_line.strip)
+          end
+        end
+
+        testable_lines.flatten
+      end
+
+      def _model_file
+        target.join("#{ name }.rb")
+      end
+
+      def testable_patterns
+        Tset::Translators::Rspec::MODEL_TRANSLATION_RULES.flat_map do |category|
+          category.values.flat_map do |rule|
+            rule.keys
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/tset/cli.rb

@@ -0,0 +1,23 @@
+require "thor"
+require "tset/commands/generate"
+
+module Tset
+  class Cli < Thor
+    include Thor::Actions
+
+    desc 'version', 'prints Tset version'
+    def version
+      puts "v#{ Tset::VERSION }"
+    end
+
+    desc 'generate', 'generates tests'
+    def generate(type = nil, name = nil, framework = 'rspec')
+      if options[:help] || (type.nil? && name.nil?)
+        invoke :help, ['generate']
+      else
+        require "tset/commands/generate"
+        Tset::Commands::Generate.new(type, name, framework, self).start
+      end
+    end
+  end
+end

data/lib/tset/commands/generate.rb

@@ -0,0 +1,37 @@
+require "pathname"
+require "active_support/inflector"
+
+module Tset
+  module Commands
+    class Generate
+
+      GENERATOR_NAMESPACE = "Tset::Generators::%sTest".freeze
+
+      class Error < ::StandardError ; end
+
+      attr_reader :type, :name, :framework, :cli, :source, :target
+
+      def initialize(type, name, framework, cli)
+        @type = type
+        @name = name.downcase
+        @framework = framework
+
+        @cli = cli
+        @source = Pathname.new(::File.dirname(__FILE__) + "/../generators/#{ @type }_test").realpath
+        @target = Pathname.pwd.realpath
+      end
+
+      def start
+        generator.start
+      end
+
+      private
+
+      def generator
+        require "tset/generators/#{ @type }_test"
+        class_name = @type.classify
+        Object.const_get(GENERATOR_NAMESPACE % class_name).new(self)
+      end
+    end
+  end
+end

data/lib/tset/generators/abstract.rb

@@ -0,0 +1,21 @@
+require "delegate"
+
+module Tset
+  module Generators
+    #
+    # An abstract superclass of Generators
+    #
+    # @param command [Tset::Commands::Generate] An instance of generate command
+    # @abstract
+    #
+    class Abstract < SimpleDelegator
+      def initialize(command)
+        super(command)
+      end
+
+      def start
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/tset/generators/controller_test.rb

@@ -0,0 +1,18 @@
+require "tset/generators/abstract"
+
+module Tset
+  module Generators
+    class ControllerTest < Abstract
+
+      def initialize(command)
+        super
+
+        cli.class.source_root(source)
+      end
+
+      def start
+
+      end
+    end
+  end
+end

data/lib/tset/generators/model_test/model_spec.rspec.tt

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe <%= config[:model_name] %> do
+end

data/lib/tset/generators/model_test/model_test.minitest.tt

@@ -0,0 +1 @@
+require 'test_helper'

data/lib/tset/generators/model_test.rb

@@ -0,0 +1,52 @@
+require "tset/generators/abstract"
+require "tset/analyzers/model"
+require "tset/writers/model_test"
+require "active_support/inflector"
+
+module Tset
+  module Generators
+    #
+    # Generates blank test files in the application
+    # Uses analyzers, translators, and writers to insert appropriate tests into the files.
+    #
+    # @param command [Tset::Commands::Generate] An instance of generate command
+    #
+    class ModelTest < Abstract
+
+      attr_reader :model_name
+
+      def initialize(command)
+        super
+        @model_name = name.classify
+
+        cli.class.source_root(source)
+      end
+
+      def start
+        assert_model_exists!
+
+        opts = {
+          model_name: @model_name
+        }
+
+        case framework
+        when 'rspec'
+          cli.template(source.join('model_spec.rspec.tt'), target.join("spec/models/#{ name }_spec.rb"), opts)
+        when 'minitest'
+          cli.template(source.join('model_test.minitest.tt'), target.join("test/models/#{ name }_test.rb"), opts)
+        end
+
+        testables = Tset::Analyzers::Model.new(name).start
+        Tset::Writers::ModelTest.new(name, testables, framework).start!
+      end
+
+      private
+
+      def assert_model_exists!
+        unless target.join("app/models/#{ name }.rb").exist?
+          raise Tset::Commands::Generate::Error.new("Unknown model: `#{ name }`")
+        end
+      end
+    end
+  end
+end

data/lib/tset/test.rb

@@ -0,0 +1,17 @@
+module Tset
+  #
+  # Contains the translated test code and the category it belongs to
+  #
+  # @param code [String] The actual test code translated from testable
+  # @param category [String] A category used for describe block
+  #
+  class Test
+
+    attr_reader :code, :category
+
+    def initialize(code, category)
+      @code = code
+      @category = category
+    end
+  end
+end

data/lib/tset/testable.rb

@@ -0,0 +1,34 @@
+require "tset/translators/rspec"
+require "tset/translators/minitest"
+require "active_support/inflector"
+
+module Tset
+  #
+  # Snippet of code that can be converted to a test by Writers
+  #
+  # @param type [String] The part of application from which the code originate (e.g. controller, model)
+  # @param code [String] The testable code itself
+  #
+  class Testable
+
+    TRANSLATOR_NAMESPACE = "Tset::Translators::%s"
+
+    attr_reader :type, :code
+
+    def initialize(type, code)
+      @type = type
+      @code = code
+    end
+
+    def to_test(framework = 'rspec')
+      translator(framework).start
+    end
+
+    private
+
+    def translator(framework)
+      class_name = framework.classify
+      Object.const_get(TRANSLATOR_NAMESPACE % class_name).new(self)
+    end
+  end
+end

data/lib/tset/translators/abstract.rb

@@ -0,0 +1,14 @@
+module Tset
+  module Translators
+    #
+    # An abstract superclass for Translators
+    #
+    # @abstract
+    class Abstract
+
+      def start
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/tset/translators/minitest.rb

@@ -0,0 +1,19 @@
+module Tset
+  module Translators
+    #
+    # Translates testable to a minitest test
+    #
+    # @param testable [Test::Testable] An instance of testable
+    #
+    class MiniTest < Abstract
+
+      def initialize(testable)
+        @testable = testable
+      end
+
+      def start
+
+      end
+    end
+  end
+end

data/lib/tset/translators/rspec.rb

@@ -0,0 +1,67 @@
+require "tset/translators/abstract"
+
+module Tset
+  module Translators
+    #
+    # Translates testable to an RSpec test
+    #
+    # @param testable [Test::Testable] An instance of testable
+    #
+    class Rspec < Abstract
+
+      MODEL_TRANSLATION_RULES = [
+        {
+          'validations' => {
+            %r(validates_presence_of (.*)) => "it { is.expected_to validate_presence_of(%s) }",
+            %r(validates_uniqueness_of (.*)) => "it { is.expected_to validate_uniqueness_of(%s) }",
+            %r(validates_length_of (.*), maximum: (\d*)) => "it { is.expected_to ensure_length_of(%s).is_at_most(%s) }",
+            %r(validates_length_of (.*), minimum: (\d*)) => "it { is.expected_to ensure_length_of(%s).is_at_least(%s) }",
+            %r(validates (\S*), presence: true) => "it { is.expected_to validate_presence_of(%s) }"
+          }
+        },
+
+        {
+          'associations' => {
+            %r(belongs_to (.*)) => "it { is.expected_to belong_to(%s) }",
+            %r(has_many (.*)) => "it { is.expected_to have_many(%s) }",
+            %r(has_one (.*)) => "it { is.expected_to have_one(%s) }",
+            %r(has_and_belongs_to_many (.*)) => "it { is.expected_to have_and_belong_to_many(%s) }",
+            %r(has_attached_file (\S*)) => "it { is.expected_to have_attached_file(%s) }"
+          }
+        }
+      ]
+
+      attr_reader :testable
+
+      def initialize(testable)
+        @testable = testable
+      end
+
+      #
+      # @return [Tset::Test] An object containing RSpec test corresponding to the testable and category
+      #
+      def start
+        send("translate_#{ testable.type }")
+      end
+
+      private
+
+      #
+      # Translates the testable from the object using MODEL_TRANSLATION_RULES
+      #
+      # @return [Tset::Test] an object containing corresponding test_code and category
+      #
+      def translate_model
+        MODEL_TRANSLATION_RULES.each do |rule|
+          rule.values.first.each do |pattern, outcome|
+            if testable.code =~ pattern
+              test_code = outcome % [$1, $2]
+              return Tset::Test.new(test_code, rule.keys.first)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/tset/version.rb

@@ -0,0 +1,3 @@
+module Tset
+  VERSION = "0.0.1"
+end

data/lib/tset/writers/abstract.rb

@@ -0,0 +1,15 @@
+#
+# Abstract superclass for Writers
+#
+# @abstract
+#
+module Tset
+  module Writers
+    class Abstract
+
+      def start!
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/tset/writers/model_test.rb

@@ -0,0 +1,89 @@
+require "tset/writers/abstract"
+require "active_support/inflector"
+
+module Tset
+  module Writers
+    #
+    # Writes the test for a model for each testable codes given
+    #
+    # @param model_name [String] a name of the model (e.g. post)
+    # @param testables [Array] an array of lines of code returned by Tset::Analyzers::Model
+    # @param framework [String] a test framework. Default to 'rspec'.
+    #
+    class ModelTest < Abstract
+
+      attr_reader :model_name, :testables, :framework, :target
+
+      def initialize(model_name, testables, framework = 'rspec')
+        @model_name = model_name
+        @testables = testables
+        @framework = framework
+
+        @target = Pathname.pwd.realpath
+      end
+
+      #
+      # @return [String] A classified version of the name (e.g. Post)
+      #
+      def class_name
+        @class_name ||= model_name.classify
+      end
+
+      def start!
+        case framework
+        when 'rspec'
+          testables.each { |testable| write_rspec(testable) }
+        when 'minitest'
+        end
+      end
+
+      private
+
+      #
+      # Translates the testable into rspec and writes to rspec file
+      #
+      # @param testable [Tset::Testable]
+      #
+      def write_rspec(testable)
+        test = testable.to_test('rspec')
+
+        file_contents = File.read(_rspec_file)
+
+        describe(test.category) unless file_contents =~ /describe "#{test.category}" do/
+        expectation(test)
+      end
+
+      #
+      # Writes a describe block
+      #
+      # @param category [String] notion that is being described
+      #
+      def describe(category)
+        file_contents = File.read(_rspec_file)
+        replacement = %Q(describe #{class_name} do
+
+  describe "#{category}" do
+  end)
+        file_contents.gsub!(/describe #{class_name} do/, replacement)
+        File.write(_rspec_file, file_contents)
+      end
+
+      #
+      # Writes an expectation
+      #
+      # @param test [Tset::Tset]
+      #
+      def expectation(test)
+        file_contents = File.read(_rspec_file)
+        replacement = %Q(  describe "#{test.category}" do
+    #{test.code})
+        file_contents.gsub!(/\s\sdescribe "#{test.category}" do/, replacement)
+        File.write(_rspec_file, file_contents)
+      end
+
+      def _rspec_file
+        target.join("spec/models/#{ @model_name }_spec.rb")
+      end
+    end
+  end
+end

data/lib/tset.rb

@@ -0,0 +1,6 @@
+require "tset/version"
+
+module Tset
+  require "tset/testable"
+  require "tset/cli"
+end

data/spec/analyzers/model_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Tset::Analyzers::Model do
+  let(:name) { 'post' }
+  let(:analyzer) { Tset::Analyzers::Model.new(name) }
+
+  before do
+    set_up_testing_directory
+    create_file("app/models/#{name}.rb")
+  end
+
+  before(:each) do
+    erase_file_content("app/models/#{name}.rb")
+  end
+
+  after do
+    chdir_back_to_root
+  end
+
+  it 'returns an array of testable codes' do
+    content = "
+  belongs_to :author
+  has_one :tipjar
+  has_many :comments
+  has_many :likes
+  lets_validate_this :forum
+  validates_presence_of :post
+  acts_as_votable
+  validates_presence_of :author
+  validates :category, presence: true
+"
+    insert_into_file("app/models/#{name}.rb", content)
+    result = analyzer.start
+
+    expect(result.map(&:code)).to match_array ['validates_presence_of :post', 'validates_presence_of :author', 'validates :category, presence: true',
+                                    'belongs_to :author', 'has_one :tipjar', 'has_many :comments', 'has_many :likes']
+
+  end
+end

data/spec/commands/generate_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe Tset::Commands::Generate do
+  let(:name) { 'post' }
+  let(:cli) { Tset::Cli.new }
+  let(:command) { Tset::Commands::Generate.new(type, name, framework, cli) }
+
+  before do
+    set_up_testing_directory
+  end
+
+  after do
+    chdir_back_to_root
+  end
+
+  describe 'model' do
+    let(:type) { 'model' }
+    let(:framework) { 'rspec' }
+
+    context 'when the model exists' do
+      before do
+        create_file("app/models/#{name}.rb")
+      end
+
+      context 'with rspec' do
+
+        before do
+          command.start
+        end
+
+        it 'generates a model spec' do
+          content = @root.join('spec/models/post_spec.rb').read
+          expect(content).to match %(require 'spec_helper')
+          expect(content).to match %(describe Post do)
+        end
+      end
+
+      context 'with minitest' do
+        let(:framework) { 'minitest' }
+
+        before do
+          command.start
+        end
+
+        it 'generates a model test' do
+          content = @root.join('test/models/post_test.rb').read
+          expect(content).to match %(require 'test_helper')
+        end
+      end
+    end
+
+    context 'when the model does not exist' do
+      it 'raises error' do
+        expect {
+          command.start
+        }.to raise_error(Tset::Commands::Generate::Error)
+      end
+    end
+
+  end
+end

data/spec/integration/generate_model_test_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe 'tset generate model post' do
+  let(:name) { 'post' }
+  let(:cli) { Tset::Cli.new }
+  let(:command) { Tset::Commands::Generate.new(type, name, framework, cli) }
+  let(:type) { 'model' }
+  let(:model_content) {
+    "validates_presence_of :author
+    validates_presence_of :title
+    validates_presence_of :body
+    validates_length_of :title, maximum: 30
+    validates_length_of :body, minimum: 50
+    belongs_to :author
+    has_and_belongs_to_many :categories
+    has_many :comments" }
+
+  before do
+    set_up_testing_directory
+    create_file("app/models/#{name}.rb")
+    insert_into_file("app/models/#{name}.rb", model_content)
+  end
+
+  after do
+    chdir_back_to_root
+  end
+
+  context 'with rspec' do
+    let(:framework) { 'rspec' }
+
+    before(:each) do
+      command.start
+    end
+
+    it 'generates the correct spec' do
+      content = @root.join('spec/models/post_spec.rb').read
+      expect(content).to match %(require 'spec_helper')
+      expect(content).to match %(describe Post do)
+      expect(content).to match %(  describe "associations" do)
+      expect(content).to match %r(    it { is.expected_to have_and_belong_to_many\(:categories\) })
+      expect(content).to match %r(    it { is.expected_to have_many\(:comments\) })
+      expect(content).to match %r(    it { is.expected_to belong_to\(:author\) })
+      expect(content).to match %(  end)
+      expect(content).to match %(  describe "validations" do)
+      expect(content).to match %r(    it { is.expected_to validate_presence_of\(:author\))
+      expect(content).to match %r(    it { is.expected_to validate_presence_of\(:title\) })
+      expect(content).to match %r(    it { is.expected_to validate_presence_of\(:body\) })
+      expect(content).to match %r(    it { is.expected_to ensure_length_of\(:title\).is_at_most\(30\) })
+      expect(content).to match %r(    it { is.expected_to ensure_length_of\(:body\).is_at_least\(50\) })
+      expect(content).to match %(  end)
+      expect(content).to match %(end)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+# Require all files under /lib
+Dir[File.expand_path('../../lib/**/*.rb', __FILE__)].each { |f| require f }
+
+# Require all spec support files
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |f| require f }
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  # Include support modules from support files
+  config.include SetupMacros
+
+  # Do not display console outputs when running tests
+  config.before { allow($stdout).to receive(:write) }
+end

data/spec/support/setup_macros.rb

@@ -0,0 +1,34 @@
+module SetupMacros
+  def set_up_testing_directory
+    @tmp = Pathname.new(@pwd = Dir.pwd).join('tmp')
+    @tmp.rmtree if @tmp.exist?
+    @tmp.mkpath
+
+    @tmp.join('apps/controllers').mkpath
+    @tmp.join('apps/models').mkpath
+
+    Dir.chdir(@tmp)
+    @root = @tmp
+  end
+
+  def chdir_back_to_root
+    Dir.chdir(@pwd)
+  end
+
+  def create_file(path)
+    file = @root.join(path)
+    file.dirname.rmtree if file.dirname.exist?
+    file.dirname.mkpath
+    FileUtils.touch(file)
+  end
+
+  def erase_file_content(path)
+    file = @root.join(path)
+    File.open(file, 'w') {}
+  end
+
+  def insert_into_file(path, content)
+    file = @root.join(path)
+    File.write(file, content)
+  end
+end

data/spec/translators/rspec_spec.rb

@@ -0,0 +1,89 @@
+require "spec_helper"
+
+describe Tset::Translators::Rspec do
+  let(:translator) { Tset::Translators::Rspec.new(testable) }
+  let(:testable) { Tset::Testable.new('model', code) }
+  let(:result) { translator.start }
+
+  context 'for models' do
+    context 'validates_presence_of :post' do
+      let(:code) { 'validates_presence_of :post' }
+
+      it 'returns a proper test' do
+        expect(result.code).to eq "it { is.expected_to validate_presence_of(:post) }"
+      end
+    end
+
+    context 'validates_uniqueness_of :title' do
+      let(:code) { 'validates_uniqueness_of :title' }
+
+      it 'returns a proper test' do
+        expect(result.code).to eq "it { is.expected_to validate_uniqueness_of(:title) }"
+      end
+    end
+
+    context 'validates_uniqueness_of :title' do
+      let(:code) { 'validates_uniqueness_of :title' }
+
+      it 'returns a proper test' do
+        expect(result.code).to eq "it { is.expected_to validate_uniqueness_of(:title) }"
+      end
+    end
+
+    context 'validates_length_of :body, maximum: 300' do
+      let(:code) { 'validates_length_of :body, maximum: 300' }
+
+      it 'returns a proper test' do
+        expect(result.code).to eq "it { is.expected_to ensure_length_of(:body).is_at_most(300) }"
+      end
+    end
+
+    context 'validates_length_of :body, minimum: 100' do
+      let(:code) { 'validates_length_of :body, minimum: 100' }
+
+      it 'returns a proper test' do
+        expect(result.code).to eq "it { is.expected_to ensure_length_of(:body).is_at_least(100) }"
+      end
+    end
+
+    context 'belongs_to :author' do
+      let(:code) { 'belongs_to :author' }
+
+      it 'returns a proper test' do
+        expect(result.code).to eq "it { is.expected_to belong_to(:author) }"
+      end
+    end
+
+    context 'has_many :comments' do
+      let(:code) { 'has_many :comments' }
+
+      it 'returns a proper test' do
+        expect(result.code).to eq "it { is.expected_to have_many(:comments) }"
+      end
+    end
+
+    context 'has_one :tag' do
+      let(:code) { 'has_one :tag' }
+
+      it 'returns a proper test' do
+        expect(result.code).to eq "it { is.expected_to have_one(:tag) }"
+      end
+    end
+
+    context 'has_and_belongs_to_many :admins' do
+      let(:code) { 'has_and_belongs_to_many :admins' }
+
+      it 'returns a proper test' do
+        expect(result.code).to eq "it { is.expected_to have_and_belong_to_many(:admins) }"
+      end
+    end
+
+    context 'has_attached_file :profile_picture' do
+      let(:code) { 'has_attached_file :profile_picture' }
+
+      it 'returns a proper test' do
+        expect(result.code).to eq "it { is.expected_to have_attached_file(:profile_picture) }"
+      end
+    end
+  end
+end

data/spec/writers/model_test_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+describe Tset::Writers::ModelTest do
+  let(:writer) { Tset::Writers::ModelTest.new(model_name, testables, framework) }
+  let(:model_name) { 'post' }
+
+  before do
+    set_up_testing_directory
+    create_file('app/models/post.rb')
+    create_file('spec/models/post_spec.rb')
+    insert_into_file('spec/models/post_spec.rb', "describe Post do")
+  end
+
+  after do
+    chdir_back_to_root
+  end
+
+  context 'rsepc' do
+    let(:framework) { 'rspec' }
+    let(:testables) { [Tset::Testable.new('model', 'validates_presence_of :author')] }
+
+    it 'writes a test' do
+      writer.start!
+
+      content = @root.join('spec/models/post_spec.rb').read
+      expect(content).to match %r(it { is.expected_to validate_presence_of\(:author\) })
+    end
+  end
+end

data/tset.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tset/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tset"
+  spec.version       = Tset::VERSION
+  spec.authors       = ["Sung Won Cho"]
+  spec.email         = ["mikeswcho@gmail.com"]
+  spec.summary       = %q{Generate tests for your Rails model.}
+  spec.description   = %q{Generate tests for your Rails model. Enter Development Driven Test.}
+  spec.homepage      = "https://github.com/sungwoncho/tset"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2.0"
+
+  spec.add_dependency "thor", "~> 0.19.1"
+  spec.add_dependency "activesupport", "~> 4.2.1"
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: tset
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sung Won Cho
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.1
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+description: Generate tests for your Rails model. Enter Development Driven Test.
+email:
+- mikeswcho@gmail.com
+executables:
+- tset
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/tset
+- lib/tset.rb
+- lib/tset/analyzers/abstract.rb
+- lib/tset/analyzers/action.rb
+- lib/tset/analyzers/model.rb
+- lib/tset/cli.rb
+- lib/tset/commands/generate.rb
+- lib/tset/generators/abstract.rb
+- lib/tset/generators/controller_test.rb
+- lib/tset/generators/controller_test/ctrl_spec.rspec.tt
+- lib/tset/generators/controller_test/ctrl_test.minitest.tt
+- lib/tset/generators/model_test.rb
+- lib/tset/generators/model_test/model_spec.rspec.tt
+- lib/tset/generators/model_test/model_test.minitest.tt
+- lib/tset/test.rb
+- lib/tset/testable.rb
+- lib/tset/translators/abstract.rb
+- lib/tset/translators/minitest.rb
+- lib/tset/translators/rspec.rb
+- lib/tset/version.rb
+- lib/tset/writers/abstract.rb
+- lib/tset/writers/model_test.rb
+- spec/analyzers/model_spec.rb
+- spec/commands/generate_spec.rb
+- spec/integration/generate_model_test_spec.rb
+- spec/spec_helper.rb
+- spec/support/setup_macros.rb
+- spec/translators/rspec_spec.rb
+- spec/writers/model_test_spec.rb
+- tset.gemspec
+homepage: https://github.com/sungwoncho/tset
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Generate tests for your Rails model.
+test_files:
+- spec/analyzers/model_spec.rb
+- spec/commands/generate_spec.rb
+- spec/integration/generate_model_test_spec.rb
+- spec/spec_helper.rb
+- spec/support/setup_macros.rb
+- spec/translators/rspec_spec.rb
+- spec/writers/model_test_spec.rb