filetesting4

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Mimo.UI.WebService;
using Mimo.BE;
using Mimo.BL;
using Mimo.DA;
using Mimo.HL;
using NUnit.Framework;
using Rhino.Mocks;

namespace MimoTest.Service
{
    [TestFixture]
    public class MyServicesTest
    {
        public static UsuarioService _usuarioService;
        public IUsuarioService _usuarioIService;

        [SetUp]
        public void SetUp()
        {
            _usuarioIService = MockRepository.GenerateStrictMock<IUsuarioService>();
        }


        [Theory]
        [TestCase(34)]
        public void ObtenerPerfilParticipante_Test_ReturnNotNull(int usuarioID)
        {
            _usuarioService = new UsuarioService();



        }

    }
}




[Test]
 public void Analyze_TooShortFileName_ErrorLoggedToService()
 {
 MockRepository mocks = new MockRepository();
 IWebService simulatedService =   MockRespository.DynamicMock<IWebService>();
  using(mocks.Record())
  {
    //we expected "Filename too short:abc.ext"
     simulatedService.LogError("bad string");
  }

      LogAnalyzer log = new LogAnalyzer(simulatedService);
      string tooShortFileName="abc.ext";
      log.Analyze(tooShortFileName);

      mocks.VerifyAll();
}
















[Test]
public void ObtenerPerfilParticipante_Test_ReturnNotNull()
{
    /*
    Int32 value = 280000;
    string result = "OK";
    MockRepository mocks = new MockRepository();
    IUsuarioService _usuarioIService = mocks.StrictMock<IUsuarioService>();
    using (mocks.Record())
    {
        _usuarioIService.Obtener_Perfil_Participante(value);
    }
    mocks.Verify(_usuarioIService.Obtener_Perfil_Participante(value));
    */
    Int32 value = 34;
    string result = "OK";
    MockRepository mocks = new MockRepository();
    IUsuarioService _usuarioIService = mocks.StrictMock<IUsuarioService>();
    Byte[] json = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject("Identificador = OK, Mensaje = Perfil Obtenido, Participante = ParticipanteBE"));
    MemoryStream resultExpected = new MemoryStream(json);
    using (mocks.Record())
    {
        _usuarioIService.Obtener_Perfil_Participante(value);
        LastCall.Return(resultExpected);
    }
    StreamReader reader = new StreamReader(_usuarioIService.Obtener_Perfil_Participante(value));
    string dataResult = reader.ReadToEnd();
    string dataResultTest = "OK";
    Assert.AreEqual("OK", dataResultTest);
}















    [TestFixture]
    public class PartialMockTheService {
        private ServiceHost host;
        private MockRepository mockRepository;
        private PartialMockService serviceMock; //(IUsuarioService _usuarioIService )

        [TestFixtureSetUp]
        public void TestFixtureSetUp()
        {
            mockRepository = new MockRepository();
            serviceMock = mockRepository.PartialMock<PartialMockService>();
            host = new ServiceHost(serviceMock);
            host.AddServiceEndpoint(typeof (IService), new BasicHttpBinding(), "http://localhost:8093/Service.svc");
            host.Open();
        }

        [Test]
        public void FacadeShouldCallTheWebserviceWithTwoOrderLines()
        {
            serviceMock.Expect(x => x.SubmitOrder(new Order()))
                            .IgnoreArguments()
                            .Return(new Acknowledgement {Success = true});
            mockRepository.ReplayAll();
            var facade = new Facade();

            Assert.IsTrue(facade.SubmitOrder());
            IList argumentsForCallsMadeOn = serviceMock.GetArgumentsForCallsMadeOn(x => x.SubmitOrder(null));
            var order = (Order) argumentsForCallsMadeOn[0][0];
            Assert.AreEqual(2, order.OrderLines.Count);
        }
    }
}


































        [TestCase(34)]
        public void ObtenerPerfilParticipante_Test_ReturnNotNull(int usuarioID)
        {
            /*
            Int32 value = 280000;
            string result = "OK";
            MockRepository mocks = new MockRepository();
            IUsuarioService _usuarioIService = mocks.StrictMock<IUsuarioService>();

            using (mocks.Record())
            {
                _usuarioIService.Obtener_Perfil_Participante(value);
            }

            mocks.Verify(_usuarioIService.Obtener_Perfil_Participante(value));
            */

            MockRepository mocks = new MockRepository();
            IUsuarioService _usuarioIService = mocks.StrictMock<IUsuarioService>();

            Byte[] json = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject("Identificador = OK, Mensaje = Perfil Obtenido, Participante = ParticipanteBE"));
            MemoryStream resultExpected = new MemoryStream(json);

            using (mocks.Record())
            {
                _usuarioIService.Obtener_Perfil_Participante(usuarioID);
                LastCall.Return(resultExpected);

                mocks.ReplayAll();
            }

            UsuarioService _usuarioService = new UsuarioService();

            Stream memory = _usuarioService.Obtener_Perfil_Participante(usuarioID);
            /*
            StreamReader reader = new StreamReader(_usuarioIService.Obtener_Perfil_Participante(usuarioID)
            string dataResult = reader.ReadToEnd();
            */
            string dataResultTest = "OK";

            Assert.AreEqual("OK", dataResultTest);
        }

















public class SettingsDomainService : ISettingsDomainService
{
    #region Declarations
    private IRepositorySettings repositorySettings;
    #endregion

    #region constructor
    public SettingsDomainService(IRepositorySettings repositorySettings)
    {
        this.repositorySettings= repositorySettings;
    }

    public Setting GetUserSetting(string GUID_User, string group, string category)
    {
        if (string.IsNullOrEmpty(GUID_User))
            throw new ArgumentNullException("GUID_User", ValidationMessages.MSG_ParameterNull);

        return repositorySettings.FindUserSettings(GUID_User, group, category);
    }
}



[TestFixture]
public class SettingsDomainServiceTest
{
    private IRepositorySettings repositorySettings;

    private SettingsService settingsService;

    [SetUp]
    public void Setup()
    {
        this.repositorySettings = MockRepository.GenerateMock<IRepositorySettings>();

        this.SettingsService = new SettingsService(repositorySettings);
    }

    #region GetUserSetting
    [Test]
    [Category("SettingsService GetUserSetting")]
    public void GetUserSettingWhenParameterIsNull()
    {
      ArgumentNullException actual = new ArgumentNullException();
      try
      {
          settingsDomainService.GetUserSetting(null, null, null);
      }
      catch (ArgumentNullException)
      {
          actual = exception;
      }

      Assert.AreEqual("GUID_User", actual.ParamName);
      Assert.AreEqual(ValidationMessages.MSG_ParameterNull, actual.Message);
    }

    [Test]
    [Category("SettingsService GetUserSetting")]
    public void GetUserSettingWhenSettingIsNull()
    {
      repositorySettings.Stub(x => x.FindUserSettings(null, null, null)).IgnoreArguments().Return(null);

      Setting actual = settingsDomainService.GetUserSetting("GUID_User", "Group", "Category");

      Assert.IsNull(actual);
    }

    [Test]
    [Category("SettingsService GetUserSetting")]
    public void GetUserSetting()
    {
        repositorySettings.Stub(x => x.FindUserSettings(null, null, null)).IgnoreArguments().Return(new Setting());

        Setting actual = settingsDomainService.GetUserSetting("GUID_User", "Group", "Category");

        Assert.NotNull(actual);
    }
    #endregion


}