moxiesoft_parallel_tests 0.4.12

data/lib/parallel_tests.rb

@@ -0,0 +1,122 @@
+require 'parallel'
+require 'parallel_tests/grouper'
+require 'parallel_tests/railtie'
+
+class ParallelTests
+  VERSION = File.read( File.join(File.dirname(__FILE__),'..','VERSION') ).strip
+
+  # parallel:spec[2,controller] <-> parallel:spec[controller]
+  def self.parse_rake_args(args)
+    num_processes = Parallel.processor_count
+    options = ""
+    if args[:count].to_s =~ /^\d*$/ # number or empty
+      num_processes = args[:count] unless args[:count].to_s.empty?
+      prefix = args[:path_prefix]
+      options = args[:options] if args[:options]
+    else # something stringy
+      prefix = args[:count]
+    end
+    [num_processes.to_i, prefix.to_s, options]
+  end
+
+  # finds all tests and partitions them into groups
+  def self.tests_in_groups(root, num_groups, options={})
+    if root.nil?
+      root = ['unit', 'functional', 'integration'].collect { |dir| File.join(Dir.pwd, 'test', dir) }
+    end
+
+    if options[:no_sort] == true
+      Grouper.in_groups(find_tests(root), num_groups)
+    else
+      Grouper.in_even_groups_by_size(tests_with_runtime(root), num_groups)
+    end
+  end
+
+  def self.run_tests(test_files, process_number, options)
+    require_list = test_files.map { |filename| "\"#{filename}\"" }.join(",")
+    cmd = "ruby -Itest #{options} -e '[#{require_list}].each {|f| require f }'"
+    execute_command(cmd, process_number)
+  end
+
+  def self.execute_command(cmd, process_number)
+    cmd = "TEST_ENV_NUMBER=#{test_env_number(process_number)} ; export TEST_ENV_NUMBER; #{cmd}"
+    f = open("|#{cmd}", 'r')
+    all = ''
+    while char = f.getc
+      char = (char.is_a?(Fixnum) ? char.chr : char) # 1.8 <-> 1.9
+      all << char
+      print char
+      STDOUT.flush
+    end
+    f.close
+    {:stdout => all, :exit_status => $?.exitstatus}
+  end
+
+  def self.find_results(test_output)
+    test_output.split("\n").map {|line|
+      line = line.gsub(/\.|F|\*/,'')
+      next unless line_is_result?(line)
+      line
+    }.compact
+  end
+
+  def self.test_env_number(process_number)
+    process_number == 0 ? '' : process_number + 1
+  end
+
+  protected
+
+  # copied from http://github.com/carlhuda/bundler Bundler::SharedHelpers#find_gemfile
+  def self.bundler_enabled?
+    return true if Object.const_defined?(:Bundler) 
+
+    previous = nil
+    current = File.expand_path(Dir.pwd)
+
+    until !File.directory?(current) || current == previous
+      filename = File.join(current, "Gemfile")
+      return true if File.exists?(filename)
+      current, previous = File.expand_path("..", current), current
+    end
+
+    false
+  end
+
+  def self.line_is_result?(line)
+    line =~ /\d+ failure/
+  end
+
+  def self.test_suffix
+    "_test.rb"
+  end
+
+  def self.tests_with_runtime(root)
+    tests = find_tests(root)
+    runtime_file = File.join(root,'..','tmp','parallel_profile.log')
+    lines = File.read(runtime_file).split("\n") rescue []
+
+    # use recorded test runtime if we got enough data
+    if lines.size * 1.5 > tests.size
+      times = Hash.new(1)
+      lines.each do |line|
+        test, time = line.split(":")
+        times[test] = time.to_f
+      end
+      tests.sort.map{|test| [test, times[test]] }
+    else # use file sizes
+      tests.sort.map{|test| [test, File.stat(test).size] }
+    end
+  end
+
+  def self.find_tests(root)
+    if root.is_a?(Array)
+      if root.first && Dir.exists?(root.first)
+        root.collect { |dir| find_tests(dir) }.flatten
+      else
+        root
+      end
+    else
+      Dir["#{root}**/**/*#{self.test_suffix}"]
+    end
+  end
+end

data/lib/tasks/parallel_tests.rake

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "/../parallel_tests/tasks")

data/spec/integration_spec.rb

@@ -0,0 +1,114 @@
+require 'spec/spec_helper'
+
+describe 'CLI' do
+  before do
+    `rm -rf #{folder}`
+  end
+
+  after do
+    `rm -rf #{folder}`
+  end
+
+  def folder
+    "/tmp/parallel_tests_tests"
+  end
+
+  def write(file, content)
+    path = "#{folder}/spec/#{file}"
+    `mkdir -p #{File.dirname(path)}` unless File.exist?(File.dirname(path))
+    File.open(path, 'w'){|f| f.write content }
+    path
+  end
+
+  def bin_folder
+    "#{File.expand_path(File.dirname(__FILE__))}/../bin"
+  end
+
+  def executable
+    "#{bin_folder}/parallel_test"
+  end
+
+  def run_specs(options={})
+    `cd #{folder} && #{executable} -t spec -n #{options[:processes]||2} #{options[:add]} 2>&1`
+  end
+
+  it "runs tests in parallel" do
+    write 'xxx_spec.rb', 'describe("it"){it("should"){puts "TEST1"}}'
+    write 'xxx2_spec.rb', 'describe("it"){it("should"){puts "TEST2"}}'
+    result = run_specs
+
+    # test ran and gave their puts
+    result.should include('TEST1')
+    result.should include('TEST2')
+
+    # all results present
+    result.scan('1 example, 0 failure').size.should == 4 # 2 results + 2 result summary
+    result.scan(/Finished in \d+\.\d+ seconds/).size.should == 2
+    result.scan(/Took \d+\.\d+ seconds/).size.should == 1 # parallel summary
+    $?.success?.should == true
+  end
+
+  it "fails when tests fail" do
+    write 'xxx_spec.rb', 'describe("it"){it("should"){puts "TEST1"}}'
+    write 'xxx2_spec.rb', 'describe("it"){it("should"){1.should == 2}}'
+    result = run_specs
+
+    result.scan('1 example, 1 failure').size.should == 2
+    result.scan('1 example, 0 failure').size.should == 2
+    $?.success?.should == false
+  end
+
+  it "can exec given commands with ENV['TEST_ENV_NUM']" do
+    result = `#{executable} -e 'ruby -e "puts ENV[:TEST_ENV_NUMBER.to_s].inspect"' -n 4`
+    result.split("\n").sort.should == %w["" "2" "3" "4"]
+  end
+
+  it "can exec given command non-parallel" do
+    result = `#{executable} -e 'ruby -e "sleep(rand(10)/100.0); puts ENV[:TEST_ENV_NUMBER.to_s].inspect"' -n 4 --non-parallel`
+    result.split("\n").should == %w["" "2" "3" "4"]
+  end
+
+  it "exists with success if all sub-processes returned success" do
+    system("#{executable} -e 'cat /dev/null' -n 4").should == true
+  end
+
+  it "exists with failure if any sub-processes returned failure" do
+    system("#{executable} -e 'test -e xxxx' -n 4").should == false
+  end
+
+  it "can run through parallel_spec / parallel_cucumber" do
+    version = `#{executable} -v`
+    `#{bin_folder}/parallel_spec -v`.should == version
+    `#{bin_folder}/parallel_cucumber -v`.should == version
+  end
+
+  it "runs faster with more processes" do
+    write 'xxx_spec.rb', 'describe("it"){it("should"){sleep 2}}'
+    write 'xxx2_spec.rb', 'describe("it"){it("should"){sleep 2}}'
+    write 'xxx3_spec.rb', 'describe("it"){it("should"){sleep 2}}'
+    write 'xxx4_spec.rb', 'describe("it"){it("should"){sleep 2}}'
+    write 'xxx5_spec.rb', 'describe("it"){it("should"){sleep 2}}'
+    write 'xxx6_spec.rb', 'describe("it"){it("should"){sleep 2}}'
+    t = Time.now
+    run_specs :processes => 6
+    expected = 10
+    (Time.now - t).should <= expected
+  end
+
+  it "can can with given files" do
+    write "x1_spec.rb", "puts '111'"
+    write "x2_spec.rb", "puts '222'"
+    write "x3_spec.rb", "puts '333'"
+    result = run_specs(:add => 'spec/x1_spec.rb spec/x3_spec.rb')
+    result.should include('111')
+    result.should include('333')
+    result.should_not include('222')
+  end
+
+  it "can run with test-options" do
+    write "x1_spec.rb", ""
+    write "x2_spec.rb", ""
+    result = run_specs(:add => "--test-options ' --version'", :processes => 2)
+    result.should =~ /\d+\.\d+\.\d+.*\d+\.\d+\.\d+/m # prints version twice
+  end
+end

data/spec/parallel_cucumber_spec.rb

@@ -0,0 +1,72 @@
+require 'spec/spec_helper'
+
+describe ParallelCucumber do
+  test_tests_in_groups(ParallelCucumber, 'features', ".feature")
+
+  describe :run_tests do
+    before do
+      ParallelCucumber.stub!(:bundler_enabled?).and_return false
+      File.stub!(:file?).with('.bundle/environment.rb').and_return false
+      File.stub!(:file?).with('script/cucumber').and_return true
+    end
+
+    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
+      ParallelCucumber.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER= /}.and_return mocked_process
+      ParallelCucumber.run_tests(['xxx'],0,'')
+    end
+
+    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
+      ParallelCucumber.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mocked_process
+      ParallelCucumber.run_tests(['xxx'],1,'')
+    end
+
+    it "returns the output" do
+      io = open('spec/spec_helper.rb')
+      ParallelCucumber.stub!(:print)
+      ParallelCucumber.should_receive(:open).and_return io
+      ParallelCucumber.run_tests(['xxx'],1,'')[:stdout].should =~ /\$LOAD_PATH << File/
+    end
+
+    it "runs bundle exec cucumber when on bundler 0.9" do
+      ParallelCucumber.stub!(:bundler_enabled?).and_return true
+      ParallelCucumber.should_receive(:open).with{|x,y| x =~ %r{bundle exec cucumber}}.and_return mocked_process
+      ParallelCucumber.run_tests(['xxx'],1,'')
+    end
+
+    it "runs script/cucumber when script/cucumber is found" do
+      ParallelCucumber.should_receive(:open).with{|x,y| x =~ %r{script/cucumber}}.and_return mocked_process
+      ParallelCucumber.run_tests(['xxx'],1,'')
+    end
+
+    it "runs cucumber by default" do
+      File.stub!(:file?).with('script/cucumber').and_return false
+      ParallelCucumber.should_receive(:open).with{|x,y| x !~ %r{(script/cucumber)|(bundle exec cucumber)}}.and_return mocked_process
+      ParallelCucumber.run_tests(['xxx'],1,'')
+    end
+
+    it "uses options passed in" do
+      ParallelCucumber.should_receive(:open).with{|x,y| x =~ %r{script/cucumber -p default}}.and_return mocked_process
+      ParallelCucumber.run_tests(['xxx'],1,'-p default')
+    end
+  end
+
+  describe :find_results do
+    it "finds multiple results in test output" do
+      output = <<EOF
+And I should not see "/en/"                                       # features/step_definitions/webrat_steps.rb:87
+
+7 scenarios (3 failed, 4 passed)
+33 steps (3 failed, 2 skipped, 28 passed)
+/apps/rs/features/signup.feature:2
+    Given I am on "/"                                           # features/step_definitions/common_steps.rb:12
+    When I click "register"                                     # features/step_definitions/common_steps.rb:6
+    And I should have "2" emails                                # features/step_definitions/user_steps.rb:25
+
+4 scenarios (4 passed)
+40 steps (40 passed)
+
+EOF
+      ParallelCucumber.find_results(output).should == ["7 scenarios (3 failed, 4 passed)", "33 steps (3 failed, 2 skipped, 28 passed)", "4 scenarios (4 passed)", "40 steps (40 passed)"]
+    end
+  end
+end

data/spec/parallel_specs_spec.rb

@@ -0,0 +1,149 @@
+require 'spec/spec_helper'
+
+describe ParallelSpecs do
+  test_tests_in_groups(ParallelSpecs, 'spec', '_spec.rb')
+
+  describe :run_tests do
+    before do
+      File.stub!(:file?).with('script/spec').and_return false
+      File.stub!(:file?).with('spec/spec.opts').and_return false
+      File.stub!(:file?).with('spec/parallel_spec.opts').and_return false
+      ParallelSpecs.stub!(:bundler_enabled?).and_return false
+    end
+
+    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
+      ParallelSpecs.should_receive(:open).with{|x,y|x=~/TEST_ENV_NUMBER= /}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],0,'')
+    end
+
+    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
+      ParallelSpecs.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "runs with color when called from cmdline" do
+      ParallelSpecs.should_receive(:open).with{|x,y| x=~/RSPEC_COLOR=1/}.and_return mocked_process
+      $stdout.should_receive(:tty?).and_return true
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "runs without color when not called from cmdline" do
+      ParallelSpecs.should_receive(:open).with{|x,y| x !~ /RSPEC_COLOR/}.and_return mocked_process
+      $stdout.should_receive(:tty?).and_return false
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "run bundle exec spec when on bundler rspec 1" do
+      File.stub!(:file?).with('script/spec').and_return false
+      ParallelSpecs.stub!(:bundler_enabled?).and_return true
+      ParallelSpecs.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-1.0.2"
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{bundle exec spec}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "run bundle exec rspec when on bundler rspec 2" do
+      File.stub!(:file?).with('script/spec').and_return false
+      ParallelSpecs.stub!(:bundler_enabled?).and_return true
+      ParallelSpecs.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-2.0.2"
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{bundle exec rspec}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "runs script/spec when script/spec can be found" do
+      File.should_receive(:file?).with('script/spec').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "runs spec when script/spec cannot be found" do
+      File.stub!(:file?).with('script/spec').and_return false
+      ParallelSpecs.should_receive(:open).with{|x,y| x !~ %r{script/spec}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "uses no -O when no opts where found" do
+      File.stub!(:file?).with('spec/spec.opts').and_return false
+      ParallelSpecs.should_receive(:open).with{|x,y| x !~ %r{spec/spec.opts}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "uses -O spec/spec.opts when found (with script/spec)" do
+      File.stub!(:file?).with('script/spec').and_return true
+      File.stub!(:file?).with('spec/spec.opts').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+-O spec/spec.opts}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "uses -O spec/parallel_spec.opts when found (with script/spec)" do
+      File.stub!(:file?).with('script/spec').and_return true
+      File.should_receive(:file?).with('spec/parallel_spec.opts').and_return true
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{script/spec\s+-O spec/parallel_spec.opts}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "uses -O spec/parallel_spec.opts with rspec1" do
+      File.should_receive(:file?).with('spec/parallel_spec.opts').and_return true
+
+      ParallelSpecs.stub!(:bundler_enabled?).and_return true
+      ParallelSpecs.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-1.0.2"
+
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{spec\s+ -O spec/parallel_spec.opts}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "uses inline options with rspec2" do
+      File.should_receive(:file?).with('spec/parallel_spec.opts').and_return true
+      File.should_receive(:read).with('spec/parallel_spec.opts').and_return "--foo\n--bar\n"
+
+      ParallelSpecs.stub!(:bundler_enabled?).and_return true
+      ParallelSpecs.stub!(:run).with("bundle show rspec").and_return "/foo/bar/rspec-2.0.2"
+
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{rspec\s+ --foo --bar}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,'')
+    end
+
+    it "uses options passed in" do
+      ParallelSpecs.should_receive(:open).with{|x,y| x =~ %r{rspec -f n}}.and_return mocked_process
+      ParallelSpecs.run_tests(['xxx'],1,'-f n')
+    end
+
+    it "returns the output" do
+      io = open('spec/spec_helper.rb')
+      ParallelSpecs.stub!(:print)
+      ParallelSpecs.should_receive(:open).and_return io
+      ParallelSpecs.run_tests(['xxx'],1,'')[:stdout].should =~ /\$LOAD_PATH << File/
+    end
+  end
+
+  describe :find_results do
+    it "finds multiple results in spec output" do
+      output = <<EOF
+....F...
+..
+failute fsddsfsd
+...
+ff.**..
+0 examples, 0 failures, 0 pending
+ff.**..
+1 example, 1 failure, 1 pending
+EOF
+
+      ParallelSpecs.find_results(output).should == ['0 examples, 0 failures, 0 pending','1 example, 1 failure, 1 pending']
+    end
+
+    it "is robust against scrambeled output" do
+      output = <<EOF
+....F...
+..
+failute fsddsfsd
+...
+ff.**..
+0 exFampl*es, 0 failures, 0 pend.ing
+ff.**..
+1 exampF.les, 1 failures, 1 pend.ing
+EOF
+
+      ParallelSpecs.find_results(output).should == ['0 examples, 0 failures, 0 pending','1 examples, 1 failures, 1 pending']
+    end
+  end
+end

data/spec/parallel_tests_spec.rb

@@ -0,0 +1,142 @@
+require 'spec/spec_helper'
+
+describe ParallelTests do
+  test_tests_in_groups(ParallelTests, 'test', '_test.rb')
+
+  describe :parse_rake_args do
+    it "should return the count" do
+      args = {:count => 2}
+      ParallelTests.parse_rake_args(args).should == [2, '', ""]
+    end
+
+    it "should default to the prefix" do
+      args = {:count => "models"}
+      ParallelTests.parse_rake_args(args).should == [Parallel.processor_count, "models", ""]
+    end
+
+    it "should return the count and prefix" do
+      args = {:count => 2, :path_prefix => "models"}
+      ParallelTests.parse_rake_args(args).should == [2, "models", ""]
+    end
+
+    it "should return the count, prefix, and options" do
+      args = {:count => 2, :path_prefix => "plain", :options => "-p default" }
+      ParallelTests.parse_rake_args(args).should == [2, "plain", "-p default"]
+    end
+  end
+
+  describe :run_tests do
+    it "uses TEST_ENV_NUMBER=blank when called for process 0" do
+      ParallelTests.should_receive(:open).with{|x,y|x=~/TEST_ENV_NUMBER= /}.and_return mocked_process
+      ParallelTests.run_tests(['xxx'],0,'')
+    end
+
+    it "uses TEST_ENV_NUMBER=2 when called for process 1" do
+      ParallelTests.should_receive(:open).with{|x,y| x=~/TEST_ENV_NUMBER=2/}.and_return mocked_process
+      ParallelTests.run_tests(['xxx'],1,'')
+    end
+
+    it "uses options" do
+      ParallelTests.should_receive(:open).with{|x,y| x=~ %r{ruby -Itest -v}}.and_return mocked_process
+      ParallelTests.run_tests(['xxx'],1,'-v')
+    end
+
+    it "returns the output" do
+      io = open('spec/spec_helper.rb')
+      ParallelTests.stub!(:print)
+      ParallelTests.should_receive(:open).and_return io
+      ParallelTests.run_tests(['xxx'],1,'')[:stdout].should =~ /\$LOAD_PATH << File/
+    end
+  end
+
+  describe :test_in_groups do
+    it "does not sort when passed false do_sort option" do
+      ParallelTests.should_not_receive(:smallest_first)
+      ParallelTests.tests_in_groups [], 1, :no_sort => true
+    end
+
+    it "does sort when not passed do_sort option" do
+      ParallelTests.stub!(:tests_with_runtime).and_return([])
+      ParallelTests::Grouper.should_receive(:smallest_first).and_return([])
+      ParallelTests.tests_in_groups [], 1
+    end
+  end
+
+  describe :find_results do
+    it "finds multiple results in test output" do
+      output = <<EOF
+Loaded suite /opt/ruby-enterprise/lib/ruby/gems/1.8/gems/rake-0.8.4/lib/rake/rake_test_loader
+Started
+..............
+Finished in 0.145069 seconds.
+
+10 tests, 20 assertions, 0 failures, 0 errors
+Loaded suite /opt/ruby-enterprise/lib/ruby/gems/1.8/gems/rake-0.8.4/lib/rake/rake_test_loader
+Started
+..............
+Finished in 0.145069 seconds.
+
+14 tests, 20 assertions, 0 failures, 0 errors
+
+EOF
+
+      ParallelTests.find_results(output).should == ['10 tests, 20 assertions, 0 failures, 0 errors','14 tests, 20 assertions, 0 failures, 0 errors']
+    end
+
+    it "is robust against scrambeled output" do
+      output = <<EOF
+Loaded suite /opt/ruby-enterprise/lib/ruby/gems/1.8/gems/rake-0.8.4/lib/rake/rake_test_loader
+Started
+..............
+Finished in 0.145069 seconds.
+
+10 tests, 20 assertions, 0 failures, 0 errors
+Loaded suite /opt/ruby-enterprise/lib/ruby/gems/1.8/gems/rake-0.8.4/lib/rake/rake_test_loader
+Started
+..............
+Finished in 0.145069 seconds.
+
+14 te.dsts, 20 assertions, 0 failures, 0 errors
+EOF
+
+      ParallelTests.find_results(output).should == ['10 tests, 20 assertions, 0 failures, 0 errors','14 tedsts, 20 assertions, 0 failures, 0 errors']
+    end
+  end
+
+  describe :bundler_enabled? do
+    before do
+      Object.stub!(:const_defined?).with(:Bundler).and_return false
+    end
+
+    it "should return false" do
+      use_temporary_directory_for do
+        ParallelTests.send(:bundler_enabled?).should == false
+      end
+    end
+
+    it "should return true when there is a constant called Bundler" do
+      use_temporary_directory_for do
+        Object.stub!(:const_defined?).with(:Bundler).and_return true
+        ParallelTests.send(:bundler_enabled?).should == true
+      end
+    end
+
+    it "should be true when there is a Gemfile" do
+      use_temporary_directory_for do
+        FileUtils.touch("Gemfile")
+        ParallelTests.send(:bundler_enabled?).should == true
+      end
+    end
+
+    it "should be true when there is a Gemfile in the parent directory" do
+      use_temporary_directory_for do
+        FileUtils.touch(File.join("..", "Gemfile"))
+        ParallelTests.send(:bundler_enabled?).should == true
+      end
+    end
+  end
+
+  it "has a version" do
+    ParallelTests::VERSION.should =~ /^\d+\.\d+\.\d+$/
+  end
+end