diff --git a/NStack/NStack.Tests/NStackAppServiceTests.cs b/NStack/NStack.Tests/NStackAppServiceTests.cs
index f079654..3331248 100644
--- a/NStack/NStack.Tests/NStackAppServiceTests.cs
+++ b/NStack/NStack.Tests/NStackAppServiceTests.cs
@@ -1,10 +1,17 @@
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.DependencyInjection;
+using Moq;
 using NStack.SDK.Models;
+using NStack.SDK.Repositories;
 using NStack.SDK.Repositories.Implementation;
+using NStack.SDK.Services;
 using NStack.SDK.Services.Implementation;
+using NStack.Tests.Translations;
 using NUnit.Framework;
+using RestSharp;
 using System;
+using System.Linq;
+using System.Net;
 using System.Threading.Tasks;
 
 namespace NStack.SDK.Tests
@@ -12,39 +19,248 @@ namespace NStack.SDK.Tests
     public class NStackAppServiceTests
     {
         private NStackAppService _service;
+        private Mock<INStackRepository> _repository;
+        private Mock<INStackLocalizeService> _localizeService;
+        private IMemoryCache _memoryCache;
+        private DataMetaWrapper<TranslationData> _danish;
+        private const int LanguageId = 42;
+        private const string LanguageLocale = "da-DK";
 
         [SetUp]
         public void Initialize()
         {
-            var repository = new NStackRepository(new NStackConfiguration
+            _repository = new Mock<INStackRepository>(MockBehavior.Strict);
+            _repository.Setup(r => r.DoRequestAsync<DataAppOpenWrapper>(It.Is<IRestRequest>(s => s.Resource.EndsWith("api/v2/open")), It.IsAny<Action<HttpStatusCode>>()))
+                .Returns(GetAppOpenMock);
+
+            var danish = new TranslationData();
+            var defaultSection = new DefaultSection();
+            defaultSection.TryAdd("text", "Jeg er på dansk");
+            danish.TryAdd("default", defaultSection);
+
+            _danish = new DataMetaWrapper<TranslationData>
             {
-                ApiKey = "qd1GiPnq8sJuChbFxjOQxV9t1AN71oIMBuWF",
-                ApplicationId = "9vJhjXzSBUxBOuQx2B2mFIZSoa2aK4UJzt7y"
-            });
+                Data = danish,
+                Meta = new MetaData
+                {
+                    Language = new Language
+                    {
+                        Direction = LanguageDirection.LRM,
+                        Id = LanguageId,
+                        IsBestFit = true,
+                        IsDefault = true,
+                        Locale = LanguageLocale,
+                        Name = "Danish"
+                    },
+                    Platform = new ResourcePlatform
+                    {
+                        Id = LanguageId,
+                        Slug = NStackPlatform.Web
+                    }
+                }
+            };
+
+            _localizeService = new Mock<INStackLocalizeService>(MockBehavior.Strict);
+            _localizeService.Setup(r => r.GetResourceAsync<TranslationData>(It.Is<int>(id => id == LanguageId)))
+                .Returns(Task.FromResult(_danish));
 
             var services = new ServiceCollection();
             services.AddMemoryCache();
             var serviceProvider = services.BuildServiceProvider();
 
-            var localizationService = new NStackLocalizeService(repository);
+            _memoryCache = serviceProvider.GetService<IMemoryCache>();
 
-            _service = new NStackAppService(repository, localizationService, serviceProvider.GetService<IMemoryCache>());
+            _service = new NStackAppService(_repository.Object, _localizeService.Object, _memoryCache);
         }
 
+        #region GetResourceAsync
         [Test]
-        public async Task DeleteMe()
+        public void GetResourceAsyncNullLocaleThrowsException()
         {
-            var userId = Guid.NewGuid();
+            var exception = Assert.ThrowsAsync<ArgumentException>(() => _service.GetResourceAsync(null, NStackPlatform.Web, "1.0.0"));
 
-            var data = await _service.AppOpenAsync(NStackPlatform.Backend, userId, "1.0.0", "development", true, false);
-            var data2 = await _service.AppOpenAsync(NStackPlatform.Backend, userId, "1.0.0", "development", true, false);
+            Assert.AreEqual("locale", exception.ParamName);
         }
 
         [Test]
-        public async Task DeleteMe2()
+        public void GetResourceAsyncEmptyLocaleThrowsException()
         {
-            var data = await _service.GetResourceAsync("da-DK", NStackPlatform.Web, "1.0.0", "development", true, false);
-            var data2 = await _service.GetResourceAsync("da-DK", NStackPlatform.Web, "1.0.0", "development", true, false);
+            var exception = Assert.ThrowsAsync<ArgumentException>(() => _service.GetResourceAsync(string.Empty, NStackPlatform.Web, "1.0.0"));
+
+            Assert.AreEqual("locale", exception.ParamName);
+        }
+
+        [Test]
+        public void GetResourceAsyncTrueDevelopmentAndProductionThrowsException()
+        {
+            Assert.ThrowsAsync<ArgumentException>(() => _service.GetResourceAsync("da-DK", NStackPlatform.Web, "1.0.0", developmentEnvironment: true, productionEnvironment: true));
+        }
+
+        [Test]
+        public async Task GetResourceAsyncFetchesLocalization()
+        {
+            ResetCounters();
+
+            DataMetaWrapper<TranslationData> resource = await _service.GetResourceAsync<TranslationData>(LanguageLocale, NStackPlatform.Web, "1.0.0");
+
+            Assert.AreEqual(_danish, resource);
+        }
+
+        [Test]
+        public async Task GetResourceAsyncDoesntFetchLocalizationOnSecondCall()
+        {
+            ResetCounters();
+
+            DataMetaWrapper<TranslationData> resource = await _service.GetResourceAsync<TranslationData>(LanguageLocale, NStackPlatform.Web, "1.0.0");
+            DataMetaWrapper<TranslationData> resource2 = await _service.GetResourceAsync<TranslationData>(LanguageLocale, NStackPlatform.Web, "1.0.0");
+
+            _repository.Verify(s => s.DoRequestAsync<DataAppOpenWrapper>(It.IsAny<IRestRequest>(), It.IsAny<Action<HttpStatusCode>>()), Times.Once());
+            _localizeService.Verify(s => s.GetResourceAsync<TranslationData>(LanguageId), Times.Once());
+        }
+
+        [Test]
+        public async Task GetResourceAsyncFetchLocalizationOnSecondCallOnExpiry()
+        {
+            ResetCounters();
+
+            DataMetaWrapper<TranslationData> resource = await _service.GetResourceAsync<TranslationData>(LanguageLocale, NStackPlatform.Web, "1.0.0");
+
+            _memoryCache.Set<DateTime>("nstack-last-updated", DateTime.UtcNow.AddHours(-2));
+
+            DataMetaWrapper<TranslationData> resource2 = await _service.GetResourceAsync<TranslationData>(LanguageLocale, NStackPlatform.Web, "1.0.0");
+
+            _repository.Verify(s => s.DoRequestAsync<DataAppOpenWrapper>(It.IsAny<IRestRequest>(), It.IsAny<Action<HttpStatusCode>>()), Times.Exactly(2));
+            _localizeService.Verify(s => s.GetResourceAsync<TranslationData>(LanguageId), Times.Exactly(2));
+        }
+
+        [Test]
+        public async Task GetResourceAsyncHonoursShouldUpdate()
+        {
+            ResetCounters();
+
+            DataMetaWrapper<TranslationData> resource = await _service.GetResourceAsync<TranslationData>(LanguageLocale, NStackPlatform.Web, "1.0.0");
+
+            _memoryCache.Set<DateTime>("nstack-last-updated", DateTime.UtcNow.AddHours(-2));
+
+            DataMetaWrapper<TranslationData> resource2 = await _service.GetResourceAsync<TranslationData>(LanguageLocale, NStackPlatform.Web, "1.0.0");
+
+            _memoryCache.Set<DateTime>("nstack-last-updated", DateTime.UtcNow.AddHours(-2));
+
+            DataMetaWrapper<TranslationData> resource3 = await _service.GetResourceAsync<TranslationData>(LanguageLocale, NStackPlatform.Web, "1.0.0");
+
+            _repository.Verify(s => s.DoRequestAsync<DataAppOpenWrapper>(It.IsAny<IRestRequest>(), It.IsAny<Action<HttpStatusCode>>()), Times.Exactly(3));
+            _localizeService.Verify(s => s.GetResourceAsync<TranslationData>(LanguageId), Times.Exactly(2));
+        }
+        #endregion
+
+        #region GetDefaultResourceAsync
+        [Test]
+        public void GetDefaultResourceAsyncTrueDevelopmentAndProductionThrowsException()
+        {
+            Assert.ThrowsAsync<ArgumentException>(() => _service.GetDefaultResourceAsync(NStackPlatform.Web, "1.0.0", developmentEnvironment: true, productionEnvironment: true));
+        }
+
+        [Test]
+        public async Task GetDefaultResourceAsyncFetchesLocalization()
+        {
+            ResetCounters();
+
+            DataMetaWrapper<TranslationData> resource = await _service.GetDefaultResourceAsync<TranslationData>(NStackPlatform.Web, "1.0.0");
+
+            Assert.AreEqual(_danish, resource);
+        }
+
+        [Test]
+        public async Task GetDefaultResourceAsyncDoesntFetchLocalizationOnSecondCall()
+        {
+            ResetCounters();
+
+            DataMetaWrapper<TranslationData> resource = await _service.GetDefaultResourceAsync<TranslationData>(NStackPlatform.Web, "1.0.0");
+            DataMetaWrapper<TranslationData> resource2 = await _service.GetDefaultResourceAsync<TranslationData>(NStackPlatform.Web, "1.0.0");
+
+            _repository.Verify(s => s.DoRequestAsync<DataAppOpenWrapper>(It.IsAny<IRestRequest>(), It.IsAny<Action<HttpStatusCode>>()), Times.Once());
+            _localizeService.Verify(s => s.GetResourceAsync<TranslationData>(LanguageId), Times.Once());
+        }
+
+        [Test]
+        public async Task GetDefaultResourceAsyncFetchLocalizationOnSecondCallOnExpiry()
+        {
+            ResetCounters();
+
+            DataMetaWrapper<TranslationData> resource = await _service.GetDefaultResourceAsync<TranslationData>(NStackPlatform.Web, "1.0.0");
+
+            _memoryCache.Set<DateTime>("nstack-last-updated", DateTime.UtcNow.AddHours(-2));
+
+            DataMetaWrapper<TranslationData> resource2 = await _service.GetDefaultResourceAsync<TranslationData>(NStackPlatform.Web, "1.0.0");
+
+            _repository.Verify(s => s.DoRequestAsync<DataAppOpenWrapper>(It.IsAny<IRestRequest>(), It.IsAny<Action<HttpStatusCode>>()), Times.Exactly(2));
+            _localizeService.Verify(s => s.GetResourceAsync<TranslationData>(LanguageId), Times.Exactly(2));
+        }
+
+        [Test]
+        public async Task GetDefaultResourceAsyncHonoursShouldUpdate()
+        {
+            ResetCounters();
+
+            DataMetaWrapper<TranslationData> resource = await _service.GetDefaultResourceAsync<TranslationData>(NStackPlatform.Web, "1.0.0");
+
+            _memoryCache.Set<DateTime>("nstack-last-updated", DateTime.UtcNow.AddHours(-2));
+
+            DataMetaWrapper<TranslationData> resource2 = await _service.GetDefaultResourceAsync<TranslationData>(NStackPlatform.Web, "1.0.0");
+
+            _memoryCache.Set<DateTime>("nstack-last-updated", DateTime.UtcNow.AddHours(-2));
+
+            DataMetaWrapper<TranslationData> resource3 = await _service.GetDefaultResourceAsync<TranslationData>(NStackPlatform.Web, "1.0.0");
+
+            _repository.Verify(s => s.DoRequestAsync<DataAppOpenWrapper>(It.IsAny<IRestRequest>(), It.IsAny<Action<HttpStatusCode>>()), Times.Exactly(3));
+            _localizeService.Verify(s => s.GetResourceAsync<TranslationData>(LanguageId), Times.Exactly(2));
+        }
+        #endregion
+
+        private void ResetCounters()
+        {
+            _memoryCache.Remove("nstack-last-updated");
+            _memoryCache.Remove($"nstack-localization-{LanguageLocale}");
+            _memoryCache.Remove("nstack-localization-default");
+            appOpenCount = 0;
+        }
+
+        private static int appOpenCount = 0;
+        private Task<DataAppOpenWrapper> GetAppOpenMock()
+        {
+            return Task.FromResult(new DataAppOpenWrapper
+            {
+                Data = new AppOpenData
+                {
+                    Count = 1,
+                    CreatedAt = DateTime.UtcNow,
+                    Localize = new []
+                    {
+                        new ResourceData
+                        {
+                            Id = LanguageId,
+                            Language = new Language
+                            {
+                                Direction = LanguageDirection.LRM,
+                                Id = LanguageId,
+                                IsBestFit = true,
+                                IsDefault = true,
+                                Locale = LanguageLocale,
+                                Name = "Danish"
+                            },
+                            LastUpdatedAt = DateTime.UtcNow.AddMonths(-1),
+                            ShouldUpdate = appOpenCount++ < 2,
+                            Url = "https://nstack.io"
+                        }
+                    },
+                    Platform = NStackPlatform.Web,
+                    Terms = Enumerable.Empty<AppOpenTerms>()
+                },
+                Meta = new AppOpenMetaData
+                {
+                    AcceptLanguage = null
+                }
+            });
         }
     }
 }
diff --git a/NStack/NStack.Tests/NStackTermsServiceTests.cs b/NStack/NStack.Tests/NStackTermsServiceTests.cs
index 246645d..8b2a804 100644
--- a/NStack/NStack.Tests/NStackTermsServiceTests.cs
+++ b/NStack/NStack.Tests/NStackTermsServiceTests.cs
@@ -4,6 +4,7 @@
 using NStack.SDK.Repositories.Implementation;
 using NStack.SDK.Services.Implementation;
 using NUnit.Framework;
+using System;
 using System.Threading.Tasks;
 
 namespace NStack.SDK.Tests
@@ -16,57 +17,113 @@ public class NStackTermsServiceTests
         [SetUp]
         public void Initialize()
         {
-            _repository = new Mock<INStackRepository>();
+            _repository = new Mock<INStackRepository>(MockBehavior.Loose);
 
-            var repository = new NStackRepository(new NStackConfiguration
-            {
-                ApiKey = "qd1GiPnq8sJuChbFxjOQxV9t1AN71oIMBuWF",
-                ApplicationId = "9vJhjXzSBUxBOuQx2B2mFIZSoa2aK4UJzt7y"
-            });
+            _service = new NStackTermsService(_repository.Object);
+        }
+
+        [Test]
+        public void GetAllTermsAsyncLanguageIsNullThrowsException()
+        {
+            ArgumentNullException exception = Assert.ThrowsAsync<ArgumentNullException>(() => _service.GetAllTermsAsync(null));
+
+            Assert.AreEqual("language", exception.ParamName);
+        }
+
+        [Test]
+        public void GetTermsVersionsAsyncTermsIdNullThrowsException()
+        {
+            ArgumentNullException exception = Assert.ThrowsAsync<ArgumentNullException>(() => _service.GetTermsVersionsAsync(null, "userId", "language"));
+
+            Assert.AreEqual("termsId", exception.ParamName);
+        }
 
-            _service = new NStackTermsService(repository);
+        [Test]
+        public void GetTermsVersionsAsyncUserIdNullThrowsException()
+        {
+            ArgumentNullException exception = Assert.ThrowsAsync<ArgumentNullException>(() => _service.GetTermsVersionsAsync("termsId", null, "language"));
+
+            Assert.AreEqual("userId", exception.ParamName);
         }
 
         [Test]
-        public async Task RemoveMeGetAll()
+        public void GetTermsVersionsAsyncLanguageNullThrowsException()
         {
-            var temp = await _service.GetAllTermsAsync("en-GB");
-            var tempDa = await _service.GetAllTermsAsync("da-DK");
-            var tempAr = await _service.GetAllTermsAsync("ar-QA");
+            ArgumentNullException exception = Assert.ThrowsAsync<ArgumentNullException>(() => _service.GetTermsVersionsAsync("termsId", "userId", null));
+
+            Assert.AreEqual("language", exception.ParamName);
         }
 
         [Test]
-        public async Task RemoveMeGetVersions()
+        public void GetNewestTermsAsyncTermsIdNullThrowsException()
         {
-            var temp = await _service.GetTermsVersionsAsync("terms", "1", "en-GB");
-            var tempDa = await _service.GetTermsVersionsAsync("terms", "1", "da-DK");
-            var tempAr = await _service.GetTermsVersionsAsync("terms", "1", "ar-QA");
+            ArgumentNullException exception = Assert.ThrowsAsync<ArgumentNullException>(() => _service.GetNewestTermsAsync(null, "userId", "language"));
+
+            Assert.AreEqual("termsId", exception.ParamName);
         }
 
         [Test]
-        public async Task RemoveMeGetNewest()
+        public void GetNewestTermsAsyncUserIdNullThrowsException()
         {
-            var temp = await _service.GetNewestTermsAsync("terms", "1", "en-GB");
-            var tempDa = await _service.GetNewestTermsAsync("terms", "1", "da-DK");
-            var tempAr = await _service.GetNewestTermsAsync("terms", "1", "ar-QA");
+            ArgumentNullException exception = Assert.ThrowsAsync<ArgumentNullException>(() => _service.GetNewestTermsAsync("termsId", null, "language"));
+
+            Assert.AreEqual("userId", exception.ParamName);
+        }
+
+        [Test]
+        public void GetNewestTermsAsyncLanguageNullThrowsException()
+        {
+            ArgumentNullException exception = Assert.ThrowsAsync<ArgumentNullException>(() => _service.GetNewestTermsAsync("termsId", "userId", null));
+
+            Assert.AreEqual("language", exception.ParamName);
         }
 
         [Test]
-        public async Task RemoveMeGetTerms()
+        public void GetTermsAsyncTermsIdTooLowThrowsException()
         {
-            var temp = await _service.GetTermsAsync(11, "1", "en-GB");
-            var tempDa = await _service.GetTermsAsync(11, "1", "da-DK");
-            var tempAr = await _service.GetTermsAsync(11, "1", "ar-QA");
+            ArgumentException exception = Assert.ThrowsAsync<ArgumentException>(() => _service.GetTermsAsync(-42, "userId", "language"));
+
+            Assert.AreEqual("termsId", exception.ParamName);
+        }
+
+        [Test]
+        public void GetTermsAsyncUserIdNullThrowsException()
+        {
+            ArgumentNullException exception = Assert.ThrowsAsync<ArgumentNullException>(() => _service.GetTermsAsync(42, null, "language"));
+
+            Assert.AreEqual("userId", exception.ParamName);
+        }
+
+        [Test]
+        public void GetTermsAsyncLanguageNullThrowsException()
+        {
+            ArgumentNullException exception = Assert.ThrowsAsync<ArgumentNullException>(() => _service.GetTermsAsync(42, "userId", null));
+
+            Assert.AreEqual("language", exception.ParamName);
+        }
+
+        [Test]
+        public void MarkReadAsyncTermsIdTooLowThrowsException()
+        {
+            ArgumentException exception = Assert.ThrowsAsync<ArgumentException>(() => _service.MarkReadAsync(-42, "userId", "language"));
+
+            Assert.AreEqual("termsId", exception.ParamName);
+        }
+
+        [Test]
+        public void MarkReadAsyncUserIdNullThrowsException()
+        {
+            ArgumentNullException exception = Assert.ThrowsAsync<ArgumentNullException>(() => _service.MarkReadAsync(42, null, "language"));
+
+            Assert.AreEqual("userId", exception.ParamName);
         }
 
         [Test]
-        public async Task RemoveMeMarkRead()
+        public void MarkReadAsyncLanguageNullThrowsException()
         {
-            var temp = await _service.MarkReadAsync(11, "1", "en-GB");
+            ArgumentNullException exception = Assert.ThrowsAsync<ArgumentNullException>(() => _service.MarkReadAsync(42, "userId", null));
 
-            var temp2 = await _service.GetTermsAsync(11, "1", "en-GB");
-            //var tempDa = await _service.GetTerms(11, "1", "da-DK");
-            //var tempAr = await _service.GetTerms(11, "1", "ar-QA");
+            Assert.AreEqual("language", exception.ParamName);
         }
     }
 }