[RUBY] Ecrire un test en mettant en œuvre l'histoire de M. Nabeats dans le monde avec du rubis

Pourquoi j'ai décidé de le faire

--Je voulais écrire un test unitaire avec rspec

• Un programme simple était bon ――Parce que l'histoire de M. Nabeats dans le monde est simple, légère et intéressante ――Parce que je l'ai inventé ――Parce que je voulais le faire

spécification

«Premièrement," Je vais faire quelque chose d'intéressant, c'est-à-dire quelque chose de drôle " --Compte de 1 à 40 ――Quand le nombre a 3, ça devient stupide ――Quand c'est un multiple de 3, ça devient stupide

• Devenir un chien quand il est un multiple de 5 (devenir un chien quand il est un multiple de 3 et 5) ――Enfin, il s’appelle «Omoro»

Tout d'abord, la mise en œuvre

omoro.rb

TSUJO_KAO_MOJI = "(･`ω ･ ´)" #Ordinaire
AHO_KAO_MOJI = "ʅ( ՞ਊ՞)ʃ≡" #Je vais être stupide
DOG_KAO_MOJI = "∪ ・ ω ・ ∪" #L'intention d'Inu

puts 'Je vais faire quelque chose d'intéressant, c'est-à-dire quelque chose de drôle'

(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 'Demain'

ruby omoro.Courir sur rb

```Je vais faire quelque chose d'intéressant, c'est-à-dire quelque chose de drôle
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∪ ・ ω ・ ∪
Demain

l'a fait. Cependant, avec cela, il n'y a pas de méthode, tout le traitement est le même et un test unitaire ne peut pas être écrit. Méthodes séparées par responsabilité.

omoro_class.rb

class Omoro
  TSUKAMI = "Je vais faire quelque chose d'intéressant, c'est-à-dire quelque chose de drôle"
  OCHI = "Demain"
  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
  
  #Faire des lignes
  def make_serif(figure, kao_moji)
    figure.to_s + kao_moji
  end
  
  #decider
  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
  
  #parler
  def speak(serif)
    puts serif
  end
end
  
omoro = Omoro.new
omoro.main(40)

Le cours Omorrow est prêt. En passant, vous pouvez modifier dynamiquement le nombre maximum à compter en passant un nombre arbitraire à la méthode principale. Si vous entrez 400, vous serez un imbécile ou un chien de 300 à 399. C'est difficile si vous utilisez la puissance humaine, mais c'est facile si vous l'écrivez par programmation.

Écrivez un test. en train d'étudier. Je n'utilise pas let parce que je ne le comprends pas bien. Si vous avez un Masakari doux, écrivez un exemple dans les commentaires.

omoro_spec.rb

require 'rspec'
require_relative '../omoro_class'

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

  it 'Nombres(1)＋ Caractère du visage((･`ω ･ ´))Pour générer les lignes de' do
    expect(Omoro.new.make_serif(1, TSUJO_KAO_MOJI)).to eq '1(･`ω ･ ´)'
  end

  it 'Nombres(3)＋ Caractère du visage(3ʅ( ՞ਊ՞)ʃ≡)Pour générer les lignes de' 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 est attaché' 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(
      "Je vais faire quelque chose d'intéressant, c'est-à-dire quelque chose de drôle\n1(･`ω ･ ´)\n2(･`ω ･ ´)\n3ʅ( ՞ਊ՞)ʃ≡\n4(･`ω ･ ´)\n5∪ ・ ω ・ ∪\n Omorrow\n").to_stdout
  end
end

Personnellement, je pense que la vérification et les principales méthodes peuvent être améliorées, mais je ne savais pas comment le faire.

Les références

[Katsura 3 fois \ -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 ] Test unitaire commençant par Rspec \ (Test unitaire ) \ | qs Developers

Tester la sortie standard avec Rspec \ -Qiita