<commit_before>import { test, setupApplicationTest } from 'ember-qunit';
import { moduloEjerciciosPilas, hacerLuegoConCallback } from '../../helpers/ejerciciosPilasTest';
import createPilasTest from '../../helpers/createPilasTest';
import sinon from 'sinon';

const nombre = 'Interactuar';

let argumentosParaApretar = {
    etiqueta: "BotonAnimado",
    nombreAnimacion: "apretar",
    animacionInteractuadoAlFinal: "prendida"
}

function setup(pilasService){
    let Interactuar = pilasService.evaluar("Interactuar");
    let alien = new (pilasService.evaluar("AlienAnimado"))(0,0);
    pilasService.evaluar("pilas").escena_actual().automata = alien;
    let boton = new (pilasService.evaluar("BotonAnimado"))(0,0);
    let ActividadError = pilasService.evaluar("ActividadError");
    let cuadricula = new (pilasService.evaluar("Cuadricula"))(0, 0, 1, 2,{},{grilla: 'invisible.png'});
    return {Interactuar, alien, boton, ActividadError, cuadricula};
}

moduloEjerciciosPilas(nombre);

test('Sanitización: Interactuar sanitiza correctamente argumentos correctos', function (assert) {
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let Interactuar = pilasService.evaluar("Interactuar");
        let instance = new Interactuar(argumentosParaApretar);
        
        instance.sanitizarArgumentos();
        assert.ok(true); // la linea anterior no debe estallar.
        resolve();
    });
});

test('Sanitización: No se puede crear una instancia de Interactuar, falta la etiqueta', function (assert) {
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let ArgumentError = pilasService.evaluar("ArgumentError");
        let Interactuar = pilasService.evaluar("Interactuar");

        assert.throws(
            () => new Interactuar({}).sanitizarArgumentos(), 
            new ArgumentError("Debe proveerse una etiqueta para verificar interacción"), 
        );
        resolve();
    });
});

test('Sin cuadrícula: No se puede interactuar con un objeto si estoy lejos', function(assert){
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let {Interactuar, alien, boton, ActividadError} = setup(pilasService);
        boton.x += 300;

        // Idealmente estas 3 líneas deberían ser un hacerLuegoConCallback, pero
        // no hay hooks para esperar un error, así que por eso se usa el iniciar y configuracionInicial
        elInteractuar = new Interactuar(argumentosParaApretar);
        elInteractuar.iniciar(alien);
        assert.throws(
            () => elInteractuar.configuracionInicial(), 
            new ActividadError("¡Acá no hay boton!")
        );
        resolve();
    });
});

test('Con cuadrícula: No se puede interactuar con un objeto si estoy en otra casilla', function(assert){
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let {Interactuar, alien, boton, ActividadError,cuadricula} = setup(pilasService);
        cuadricula.agregarActor(alien,0,0);
        cuadricula.agregarActor(boton,0,1);

        // Idealmente estas 3 líneas deberían ser un hacerLuegoConCallback, pero
        // no hay hooks para esperar un error, así que por eso se usa el iniciar y configuracionInicial
        elInteractuar = new Interactuar(argumentosParaApretar);
        elInteractuar.iniciar(alien);
        assert.throws(
            () => elInteractuar.configuracionInicial(), 
            new ActividadError("¡Acá no hay boton!")
        );
        resolve();
    });
});

test('Sin cuadrícula: Interactúa cuando está el objeto. AnimacionInteractuadoFinal funciona correctamente', function(assert){
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let {Interactuar, alien, boton} = setup(pilasService);

        hacerLuegoConCallback(alien,Interactuar,argumentosParaApretar,() => {
            assert.equal(argumentosParaApretar.animacionInteractuadoAlFinal, boton.nombreAnimacionActual());
            resolve();
        });
    });
});

test('Con cuadrícula: Interactúa cuando está el objeto', function(assert){
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let {Interactuar, alien, boton, cuadricula} = setup(pilasService);
        cuadricula.agregarActor(alien,0,0);
        cuadricula.agregarActor(boton,0,0);
        boton.x += 300; // para asegurar que no está chequeando por proximidad sino por casilla
        
        hacerLuegoConCallback(alien,Interactuar,argumentosParaApretar,() => {
            assert.equal(argumentosParaApretar.animacionInteractuadoAlFinal, boton.nombreAnimacionActual());
            resolve();
        });
    });
});

test(`animacionInteractuadoMientras funciona correctamente`, function (assert) {
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let Alien = pilasService.evaluar("AlienAnimado");
        let Interactuar = pilasService.evaluar("Interactuar");
        let argumentos = {
            etiqueta: "AlienAnimado",
            animacionInteractuadoMientras: "hablar",
            nombreAnimacion: "apretar"
        };

        let alienInstance = new Alien(0, 0);
        let spy = sinon.spy(alienInstance, 'cargarAnimacion')
        let interactuarInstance = new Interactuar(argumentos);

        sinon.stub(Interactuar.prototype, 'interactuado').callsFake(() => {
            return alienInstance;
        })

        interactuarInstance.preAnimacion();

        assert.ok(argumentos.animacionInteractuadoMientras === interactuarInstance.interactuado().nombreAnimacionActual());
        assert.ok(spy.calledOnce);
        spy.restore();
        resolve();
    });
});<commit_msg>refactor test animacionInteractuadoMientras<commit_after>import { test, setupApplicationTest } from 'ember-qunit';
import { moduloEjerciciosPilas, hacerLuegoConCallback } from '../../helpers/ejerciciosPilasTest';
import createPilasTest from '../../helpers/createPilasTest';
import sinon from 'sinon';

const nombre = 'Interactuar';

let argumentosParaApretar = {
    etiqueta: "BotonAnimado",
    nombreAnimacion: "apretar",
    animacionInteractuadoAlFinal: "prendida"
}

function setup(pilasService){
    let Interactuar = pilasService.evaluar("Interactuar");
    let alien = new (pilasService.evaluar("AlienAnimado"))(0,0);
    pilasService.evaluar("pilas").escena_actual().automata = alien;
    let boton = new (pilasService.evaluar("BotonAnimado"))(0,0);
    let ActividadError = pilasService.evaluar("ActividadError");
    let cuadricula = new (pilasService.evaluar("Cuadricula"))(0, 0, 1, 2,{},{grilla: 'invisible.png'});
    return {Interactuar, alien, boton, ActividadError, cuadricula};
}

moduloEjerciciosPilas(nombre);

test('Sanitización: Interactuar sanitiza correctamente argumentos correctos', function (assert) {
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let Interactuar = pilasService.evaluar("Interactuar");
        let instance = new Interactuar(argumentosParaApretar);
        
        instance.sanitizarArgumentos();
        assert.ok(true); // la linea anterior no debe estallar.
        resolve();
    });
});

test('Sanitización: No se puede crear una instancia de Interactuar, falta la etiqueta', function (assert) {
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let ArgumentError = pilasService.evaluar("ArgumentError");
        let Interactuar = pilasService.evaluar("Interactuar");

        assert.throws(
            () => new Interactuar({}).sanitizarArgumentos(), 
            new ArgumentError("Debe proveerse una etiqueta para verificar interacción"), 
        );
        resolve();
    });
});

test('Sin cuadrícula: No se puede interactuar con un objeto si estoy lejos', function(assert){
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let {Interactuar, alien, boton, ActividadError} = setup(pilasService);
        boton.x += 300;

        // Idealmente estas 3 líneas deberían ser un hacerLuegoConCallback, pero
        // no hay hooks para esperar un error, así que por eso se usa el iniciar y configuracionInicial
        elInteractuar = new Interactuar(argumentosParaApretar);
        elInteractuar.iniciar(alien);
        assert.throws(
            () => elInteractuar.configuracionInicial(), 
            new ActividadError("¡Acá no hay boton!")
        );
        resolve();
    });
});

test('Con cuadrícula: No se puede interactuar con un objeto si estoy en otra casilla', function(assert){
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let {Interactuar, alien, boton, ActividadError,cuadricula} = setup(pilasService);
        cuadricula.agregarActor(alien,0,0);
        cuadricula.agregarActor(boton,0,1);

        // Idealmente estas 3 líneas deberían ser un hacerLuegoConCallback, pero
        // no hay hooks para esperar un error, así que por eso se usa el iniciar y configuracionInicial
        elInteractuar = new Interactuar(argumentosParaApretar);
        elInteractuar.iniciar(alien);
        assert.throws(
            () => elInteractuar.configuracionInicial(), 
            new ActividadError("¡Acá no hay boton!")
        );
        resolve();
    });
});

test('Sin cuadrícula: Interactúa cuando está el objeto. AnimacionInteractuadoFinal funciona correctamente', function(assert){
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let {Interactuar, alien, boton} = setup(pilasService);

        hacerLuegoConCallback(alien,Interactuar,argumentosParaApretar,() => {
            assert.equal(argumentosParaApretar.animacionInteractuadoAlFinal, boton.nombreAnimacionActual());
            resolve();
        });
    });
});

test('Con cuadrícula: Interactúa cuando está el objeto', function(assert){
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let {Interactuar, alien, boton, cuadricula} = setup(pilasService);
        cuadricula.agregarActor(alien,0,0);
        cuadricula.agregarActor(boton,0,0);
        boton.x += 300; // para asegurar que no está chequeando por proximidad sino por casilla
        
        hacerLuegoConCallback(alien,Interactuar,argumentosParaApretar,() => {
            assert.equal(argumentosParaApretar.animacionInteractuadoAlFinal, boton.nombreAnimacionActual());
            resolve();
        });
    });
});

test(`animacionInteractuadoMientras funciona correctamente`, function (assert) {
    return createPilasTest(this, 'EscenaTests', (pilas, resolve, pilasService) => {
        let {Interactuar, alien} = setup(pilasService);
        let argumentos = {
            etiqueta: "AlienAnimado",
            animacionInteractuadoMientras: "hablar",
            nombreAnimacion: "apretar"
        };
        let elInteractuar = new Interactuar(argumentos);

        let spy = sinon.spy(alien, 'cargarAnimacion')
        sinon.stub(Interactuar.prototype, 'interactuado').callsFake(() => {
            return alien;
        })

        elInteractuar.preAnimacion();
        assert.equal(argumentos.animacionInteractuadoMientras, elInteractuar.interactuado().nombreAnimacionActual());
        assert.ok(spy.calledOnce);

        spy.restore();
        resolve();
    });
});
{'fraction_non_alphanumeric': 0.11596240007028025, 'fraction_numerical': 0.004392515154177282, 'mean_word_length': 3.5536, 'pattern_counts': {'":': 0, '<': 3, '<?xml version=': 0, '>': 29, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'dir': 'git-commits-cleaned', 'id': '4902828', 'n_tokens_mistral': 3634, 'n_tokens_neox': 3585, 'n_words': 745}