[RUBY] Schreiben Sie einen Test, indem Sie die Geschichte von Mr. Nabeats in der Welt mit Rubin umsetzen

Warum ich mich dazu entschlossen habe

• Ich wollte einen Unit-Test mit rspec schreiben
• Ein einfaches Programm war gut ――Weil die Geschichte von Mr. Nabeats in der Welt einfach, schlank und interessant ist »Weil ich es mir ausgedacht habe »Weil ich es machen wollte

Spezifikation

――Zunächst: "Ich werde etwas Interessantes machen, das heißt etwas Lustiges."

• Anzahl von 1 bis 40 ――Wenn die Zahl 3 hat, wird es dumm ――Wenn es ein Vielfaches von 3 ist, wird es dumm
• Werden Sie ein Hund, wenn es ein Vielfaches von 5 ist (werden Sie ein Hund, wenn es ein Vielfaches von 3 und 5 ist) "Endlich heißt es" Omoro ".

Erstens die Implementierung

omoro.rb

TSUJO_KAO_MOJI = "(･`ω ･ ´)" #Normal
AHO_KAO_MOJI = "ʅ( ՞ਊ՞)ʃ≡" #Ich werde dumm sein
DOG_KAO_MOJI = "∪ ・ ω ・ ∪" #Inus Absicht

puts 'Ich werde etwas Interessantes machen, das heißt etwas Lustiges'

(1..40).each do |figure|
  sleep 0.5
  
  if figure % 5 == 0
    puts figure.to_s + DOG_KAO_MOJI
    next
  end

  if figure % 3 == 0
    puts figure.to_s + AHO_KAO_MOJI
    next
  end

  if /3/ =~ figure.to_s
    puts figure.to_s + AHO_KAO_MOJI
    next
  end
  
  puts figure.to_s + TSUJO_KAO_MOJI
end

puts 'Morgen'

ruby omoro.Laufen Sie auf rb

```Ich werde etwas Interessantes machen, das heißt etwas Lustiges
1(･`ω ･ ´)
2(･`ω ･ ´)
3ʅ( ՞ਊ՞)ʃ≡
4(･`ω ･ ´)
5∪ ・ ω ・ ∪
6ʅ( ՞ਊ՞)ʃ≡
7(･`ω ･ ´)
8(･`ω ･ ´)
9ʅ( ՞ਊ՞)ʃ≡
10∪ ・ ω ・ ∪
11(･`ω ･ ´)
12ʅ( ՞ਊ՞)ʃ≡
13ʅ( ՞ਊ՞)ʃ≡
14(･`ω ･ ´)
15∪ ・ ω ・ ∪
16(･`ω ･ ´)
17(･`ω ･ ´)
18ʅ( ՞ਊ՞)ʃ≡
19(･`ω ･ ´)
20∪ ・ ω ・ ∪
21ʅ( ՞ਊ՞)ʃ≡
22(･`ω ･ ´)
23ʅ( ՞ਊ՞)ʃ≡
24ʅ( ՞ਊ՞)ʃ≡
25∪ ・ ω ・ ∪
26(･`ω ･ ´)
27ʅ( ՞ਊ՞)ʃ≡
28(･`ω ･ ´)
29(･`ω ･ ´)
30∪ ・ ω ・ ∪
31ʅ( ՞ਊ՞)ʃ≡
32ʅ( ՞ਊ՞)ʃ≡
33ʅ( ՞ਊ՞)ʃ≡
34ʅ( ՞ਊ՞)ʃ≡
35∪ ・ ω ・ ∪
36ʅ( ՞ਊ՞)ʃ≡
37ʅ( ՞ਊ՞)ʃ≡
38ʅ( ՞ਊ՞)ʃ≡
39ʅ( ՞ਊ՞)ʃ≡
40∪ ・ ω ・ ∪
Morgen

erledigt. Damit gibt es jedoch keine Methode, die gesamte Verarbeitung ist gleich und ein Komponententest kann nicht geschrieben werden. Getrennte Methoden nach Verantwortung.

omoro_class.rb

class Omoro
  TSUKAMI = "Ich werde etwas Interessantes machen, das heißt etwas Lustiges"
  OCHI = "Morgen"
  TSUJO_KAO_MOJI = "(･`ω ･ ´)"
  AHO_KAO_MOJI = "ʅ( ՞ਊ՞)ʃ≡"
  DOG_KAO_MOJI = "∪ ・ ω ・ ∪"
  
  #Neta
  def main(max_kazu = 40)
    speak(TSUKAMI)
    
    (1..max_kazu).each do |figure|
      sleep 1
      kao_moji = verification(figure)
      serif = make_serif(figure, kao_moji)
      speak(serif)
    end
    
    speak(OCHI)
  end
  
  #Linien machen
  def make_serif(figure, kao_moji)
    figure.to_s + kao_moji
  end
  
  #zu entscheiden
  def verification(figure)
    if figure % 5 == 0
      return DOG_KAO_MOJI
    end
    
    if figure % 3 == 0 || /3/ =~ figure.to_s
      return AHO_KAO_MOJI
    end
    TSUJO_KAO_MOJI
  end
  
  #sprechen
  def speak(serif)
    puts serif
  end
end
  
omoro = Omoro.new
omoro.main(40)

Morgen ist der Unterricht fertig. Nebenbei können Sie die maximal zu zählende Zahl dynamisch ändern, indem Sie eine beliebige Zahl an die Hauptmethode übergeben. Wenn Sie 400 eingeben, sind Sie ein Narr oder ein Hund von 300 bis 399. Es ist schwer, wenn man menschliche Kraft einsetzt, aber es ist einfach, wenn man sie programmgesteuert schreibt.

Schreiben Sie einen Test. studieren. Ich benutze let nicht, weil ich es nicht gut verstehe. Wenn Sie einen sanften Masakari haben, schreiben Sie bitte ein Beispiel in die Kommentare.

omoro_spec.rb

require 'rspec'
require_relative '../omoro_class'

RSpec.describe Omoro do
    TSUJO_KAO_MOJI = "(･`ω ･ ´)"
    AHO_KAO_MOJI = "ʅ( ՞ਊ՞)ʃ≡"
    DOG_KAO_MOJI = "∪ ・ ω ・ ∪"

  it 'Zahlen(1)＋ Gesichtscharakter((･`ω ･ ´))Um die Zeilen von zu generieren' do
    expect(Omoro.new.make_serif(1, TSUJO_KAO_MOJI)).to eq '1(･`ω ･ ´)'
  end

  it 'Zahlen(3)＋ Gesichtscharakter(3ʅ( ՞ਊ՞)ʃ≡)Um die Zeilen von zu generieren' do
    expect(Omoro.new.make_serif(3, AHO_KAO_MOJI)).to eq '3ʅ( ՞ਊ՞)ʃ≡'
  end

  it 'Inu' do
    expect(Omoro.new.make_serif(5, DOG_KAO_MOJI)).to eq '5∪ ・ ω ・ ∪'
  end

  it '3 ist beigefügt' do
    expect(Omoro.new.make_serif(33, 'ʅ( ՞ਊ՞)ʃ≡')).to eq '33ʅ( ՞ਊ՞)ʃ≡'
  end

  it 'verification' do
    omoro = Omoro.new
    (1..40).each do |figure|
      if figure % 5 == 0
        expect(omoro.verification(figure)).to eq DOG_KAO_MOJI
      elsif figure % 3 == 0 || /3/ =~ figure.to_s
        expect(omoro.verification(figure)).to eq AHO_KAO_MOJI
      else
        expect(omoro.verification(figure)).to eq TSUJO_KAO_MOJI
      end
    end
  end

  it 'main' do
    omoro = Omoro.new
    expect { omoro.main(5) }.to output(
      "Ich werde etwas Interessantes machen, das heißt etwas Lustiges\n1(･`ω ･ ´)\n2(･`ω ･ ´)\n3ʅ( ՞ਊ՞)ʃ≡\n4(･`ω ･ ´)\n5∪ ・ ω ・ ∪\n Morgen\n").to_stdout
  end
end

Ich persönlich bin der Meinung, dass die Überprüfung und die wichtigsten Methoden verbessert werden können, aber ich wusste nicht, wie ich das machen soll.

Verweise

[Katsura 3 mal \ -Wikipedia](https://ja.wikipedia.org/wiki/%E6%A1%82%E4%B8%89%E5%BA%A6#%E4%B8%96%E7%95% 8C% E3% 81% AE% E3% 83% 8A% E3% 83% 99% E3% 82% A2% E3% 83% 84)

[\ Ruby ] Unit-Test beginnend mit Rspec \ (Unit-Test ) \ | qs Developers

Standardausgabe mit Rspec \ -Qiita testen